This commit removes the old bit-vector solver code.
#-----------------------------------------------------------------------------#
# Tell CMake where to find our dependencies
-if(ABC_DIR)
- list(APPEND CMAKE_PREFIX_PATH "${ABC_DIR}")
-endif()
if(GLPK_DIR)
list(APPEND CMAKE_PREFIX_PATH "${GLPK_DIR}")
endif()
# >> 3-valued: IGNORE ON OFF
# > allows to detect if set by user (default: IGNORE)
# > only necessary for options set for ENABLE_BEST
-cvc5_option(USE_ABC "Use ABC for AIG bit-blasting")
cvc5_option(USE_CLN "Use CLN instead of GMP")
cvc5_option(USE_CRYPTOMINISAT "Use CryptoMiniSat SAT solver")
cvc5_option(USE_GLPK "Use GLPK simplex solver")
# installed via the corresponding contrib/get-* script and if not found, we
# check the intalled system version. If the user provides a directory we
# immediately fail if the dependency was not found at the specified location.
-set(ABC_DIR "" CACHE STRING "Set ABC install directory")
set(GLPK_DIR "" CACHE STRING "Set GLPK install directory")
# Prepend binaries with prefix on make install
add_definitions(-DCVC5_VALGRIND)
endif()
-if(USE_ABC)
- find_package(ABC REQUIRED)
- add_definitions(-DCVC5_USE_ABC ${ABC_ARCH_FLAGS})
-endif()
-
find_package(CaDiCaL REQUIRED)
if(USE_CLN)
print_config("Python2 " ${USE_PYTHON2})
print_config("Interprocedural opt. " ${ENABLE_IPO})
message("")
-print_config("ABC " ${USE_ABC})
print_config("CryptoMiniSat " ${USE_CRYPTOMINISAT} FOUND_SYSTEM ${CryptoMiniSat_FOUND_SYSTEM})
print_config("GLPK " ${USE_GLPK})
print_config("Kissat " ${USE_KISSAT} FOUND_SYSTEM ${Kissat_FOUND_SYSTEM})
message("")
print_config("Api docs " ${BUILD_DOCS})
message("")
-if(ABC_DIR)
- print_config("ABC dir " ${ABC_DIR})
-endif()
if(GLPK_DIR)
print_config("GLPK dir " ${GLPK_DIR})
endif()
cvc5's license is more permissive; see above discussion.)
-ABC library (Improved Bit-Vector Support)
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-`ABC <http://www.eecs.berkeley.edu/~alanmi/abc/>`_ (A System for Sequential
-Synthesis and Verification) is a library for synthesis and verification of logic
-circuits. This dependency may improve performance of the eager bit-vector
-solver. When enabled, the bit-blasted formula is encoded into
-and-inverter-graphs (AIG) and ABC is used to simplify these AIGs.
-
-ABC can be installed using the ``contrib/get-abc`` script. Configure cvc5 with
-``configure.sh --abc`` to build with this dependency.
-
-
Editline library (Improved Interactive Experience)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+++ /dev/null
-###############################################################################
-# Top contributors (to current version):
-# Mathias Preiner
-#
-# This file is part of the cvc5 project.
-#
-# Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
-# in the top-level source directory and their institutional affiliations.
-# All rights reserved. See the file COPYING in the top-level source
-# directory for licensing information.
-# #############################################################################
-#
-# Find ABC
-# ABC_FOUND - system has ABC lib
-# ABC_INCLUDE_DIR - the ABC include directory
-# ABC_LIBRARIES - Libraries needed to use ABC
-# ABC_ARCH_FLAGS - Platform specific compile flags
-##
-
-# Note: contrib/get-abc copies header files to deps/install/include/abc.
-# However, includes in ABC headers are not prefixed with "abc/" and therefore
-# we have to look for headers in include/abc instead of include/.
-find_path(ABC_INCLUDE_DIR NAMES base/abc/abc.h PATH_SUFFIXES abc)
-find_library(ABC_LIBRARIES NAMES abc)
-find_program(ABC_ARCH_FLAGS_PROG NAMES arch_flags)
-
-if(ABC_ARCH_FLAGS_PROG)
- execute_process(COMMAND ${ABC_ARCH_FLAGS_PROG}
- OUTPUT_VARIABLE ABC_ARCH_FLAGS)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(ABC
- DEFAULT_MSG
- ABC_INCLUDE_DIR ABC_LIBRARIES ABC_ARCH_FLAGS)
-
-mark_as_advanced(ABC_INCLUDE_DIR ABC_LIBRARIES ABC_ARCH_FLAGS)
-if(ABC_LIBRARIES)
- message(STATUS "Found ABC libs: ${ABC_LIBRARIES}")
-endif()
The following flags enable optional packages (disable with --no-<option name>).
--cln use CLN instead of GMP
--glpk use GLPK simplex solver
- --abc use the ABC AIG library
--cryptominisat use the CryptoMiniSat SAT solver
--kissat use the Kissat SAT solver
--poly use the LibPoly library [default=yes]
--editline support the editline library
Optional Path to Optional Packages:
- --abc-dir=PATH path to top level of ABC source tree
--glpk-dir=PATH path to top level of GLPK installation
--dep-path=PATH path to a dependency installation dir
buildtype=default
-abc=default
asan=default
assertions=default
auto_download=default
werror=default
ipo=default
-abc_dir=default
glpk_dir=default
#--------------------------------------------------------------------------#
-h|--help) usage;;
- --abc) abc=ON;;
- --no-abc) abc=OFF;;
-
--asan) asan=ON;;
--no-asan) asan=OFF;;
# Best configuration
--best)
ipo=ON
- abc=ON
cln=ON
cryptominisat=ON
glpk=ON
--editline) editline=ON;;
--no-editline) editline=OFF;;
- --abc-dir) die "missing argument to $1 (try -h)" ;;
- --abc-dir=*) abc_dir=${1##*=} ;;
-
--glpk-dir) die "missing argument to $1 (try -h)" ;;
--glpk-dir=*) glpk_dir=${1##*=} ;;
&& cmake_opts="$cmake_opts -DENABLE_PROFILING=$profiling"
[ $editline != default ] \
&& cmake_opts="$cmake_opts -DUSE_EDITLINE=$editline"
-[ $abc != default ] \
- && cmake_opts="$cmake_opts -DUSE_ABC=$abc"
[ $cln != default ] \
&& cmake_opts="$cmake_opts -DUSE_CLN=$cln"
[ $cryptominisat != default ] \
&& cmake_opts="$cmake_opts -DUSE_POLY=$poly"
[ $cocoa != default ] \
&& cmake_opts="$cmake_opts -DUSE_COCOA=$cocoa"
-[ "$abc_dir" != default ] \
- && cmake_opts="$cmake_opts -DABC_DIR=$abc_dir"
[ "$glpk_dir" != default ] \
&& cmake_opts="$cmake_opts -DGLPK_DIR=$glpk_dir"
[ "$dep_path" != default ] \
+++ /dev/null
-#!/usr/bin/env bash
-#
-source "$(dirname "$0")/get-script-header.sh"
-
-ABC_DIR="$DEPS_DIR/abc"
-commit=3d7034bf619aada30b0ba1e8afcb151d304ab556
-
-setup_dep "https://github.com/berkeley-abc/abc/archive/$commit.tar.gz" "$ABC_DIR"
-cd "$ABC_DIR"
-
-# Strip out libSupport.c, it is in charge of loading extensions and we
-# don't want different behavior based on ABC_LIB_PATH, or based on what
-# .so is in the current directory!
-cp src/base/main/module.make src/base/main/module.make.orig
-grep -v 'libSupport\.c' src/base/main/module.make.orig > src/base/main/module.make
-cp src/base/main/mainInit.c src/base/main/mainInit.c.orig
-sed 's,\( *\)\(.*Libs_Init(\),\1//\2,;s,\( *\)\(.*Libs_End(\),\1//\2,' src/base/main/mainInit.c.orig > src/base/main/mainInit.c
-
-# Build optimized, without readline, without pthreads.
-# These aren't necessary for our usage and we don't want the dependencies.
-make -j$(nproc) libabc.a OPTFLAGS=-O ABC_USE_NO_READLINE=1 ABC_USE_NO_PTHREADS=1
-mv libabc.a libabc-static.a
-install_lib libabc-static.a
-make clean
-
-make -j$(nproc) libabc.a OPTFLAGS='-O -fPIC' ABC_USE_NO_READLINE=1 ABC_USE_NO_PTHREADS=1
-install_lib libabc.a
-install_bin arch_flags
-
-# Copy headers and preserve subdirectories
-cd src
-mkdir -p "$INSTALL_INCLUDE_DIR/abc"
-
-if [[ "$OSTYPE" == "darwin"* ]]; then
- rsync -R -r $(find . -name '*.h') "$INSTALL_INCLUDE_DIR/abc"
-else
- cp --parents $(find . -name '*.h') "$INSTALL_INCLUDE_DIR/abc"
-fi
-
-echo
-echo ===================== Now configure cvc5 with =====================
-echo ./configure.sh --abc
preprocessing/passes/apply_substs.h
preprocessing/passes/bool_to_bv.cpp
preprocessing/passes/bool_to_bv.h
- preprocessing/passes/bv_abstraction.cpp
- preprocessing/passes/bv_abstraction.h
preprocessing/passes/bv_eager_atoms.cpp
preprocessing/passes/bv_eager_atoms.h
preprocessing/passes/bv_gauss.cpp
proof/alethe/alethe_post_processor.h
proof/alethe/alethe_proof_rule.cpp
proof/alethe/alethe_proof_rule.h
- prop/bv_sat_solver_notify.h
- prop/bvminisat/bvminisat.cpp
- prop/bvminisat/bvminisat.h
- prop/bvminisat/core/Dimacs.h
- prop/bvminisat/core/Solver.cc
- prop/bvminisat/core/Solver.h
- prop/bvminisat/core/SolverTypes.h
- prop/bvminisat/mtl/Alg.h
- prop/bvminisat/mtl/Alloc.h
- prop/bvminisat/mtl/Heap.h
- prop/bvminisat/mtl/IntTypes.h
- prop/bvminisat/mtl/Map.h
- prop/bvminisat/mtl/Queue.h
- prop/bvminisat/mtl/Sort.h
- prop/bvminisat/mtl/Vec.h
- prop/bvminisat/mtl/XAlloc.h
- prop/bvminisat/simp/SimpSolver.cc
- prop/bvminisat/simp/SimpSolver.h
- prop/bvminisat/utils/Options.h
prop/cadical.cpp
prop/cadical.h
prop/cnf_stream.cpp
theory/builtin/theory_builtin_type_rules.h
theory/builtin/type_enumerator.cpp
theory/builtin/type_enumerator.h
- theory/bv/abstraction.cpp
- theory/bv/abstraction.h
- theory/bv/bitblast/aig_bitblaster.cpp
- theory/bv/bitblast/aig_bitblaster.h
theory/bv/bitblast/bitblast_proof_generator.cpp
theory/bv/bitblast/bitblast_proof_generator.h
theory/bv/bitblast/bitblast_strategies_template.h
theory/bv/bitblast/bitblast_utils.h
theory/bv/bitblast/bitblaster.h
- theory/bv/bitblast/eager_bitblaster.cpp
- theory/bv/bitblast/eager_bitblaster.h
- theory/bv/bitblast/lazy_bitblaster.cpp
- theory/bv/bitblast/lazy_bitblaster.h
theory/bv/bitblast/node_bitblaster.cpp
theory/bv/bitblast/node_bitblaster.h
theory/bv/bitblast/proof_bitblaster.cpp
theory/bv/bitblast/proof_bitblaster.h
- theory/bv/bv_eager_solver.cpp
- theory/bv/bv_eager_solver.h
- theory/bv/bv_inequality_graph.cpp
- theory/bv/bv_inequality_graph.h
- theory/bv/bv_quick_check.cpp
- theory/bv/bv_quick_check.h
theory/bv/bv_solver.h
theory/bv/bv_solver_bitblast.cpp
theory/bv/bv_solver_bitblast.h
theory/bv/bv_solver_bitblast_internal.cpp
theory/bv/bv_solver_bitblast_internal.h
- theory/bv/bv_solver_layered.cpp
- theory/bv/bv_solver_layered.h
- theory/bv/bv_subtheory.h
- theory/bv/bv_subtheory_algebraic.cpp
- theory/bv/bv_subtheory_algebraic.h
- theory/bv/bv_subtheory_bitblast.cpp
- theory/bv/bv_subtheory_bitblast.h
- theory/bv/bv_subtheory_core.cpp
- theory/bv/bv_subtheory_core.h
- theory/bv/bv_subtheory_inequality.cpp
- theory/bv/bv_subtheory_inequality.h
theory/bv/int_blaster.cpp
theory/bv/int_blaster.h
theory/bv/proof_checker.cpp
theory/bv/proof_checker.h
- theory/bv/slicer.cpp
- theory/bv/slicer.h
theory/bv/theory_bv.cpp
theory/bv/theory_bv.h
theory/bv/theory_bv_rewrite_rules.h
if(ENABLE_VALGRIND)
target_include_directories(cvc5-obj PUBLIC ${Valgrind_INCLUDE_DIR})
endif()
-if(USE_ABC)
- target_include_directories(cvc5-obj PRIVATE ${ABC_INCLUDE_DIR})
- target_link_libraries(cvc5-obj PUBLIC ${ABC_LIBRARIES})
-endif()
add_dependencies(cvc5-obj CaDiCaL)
target_include_directories(cvc5-obj PRIVATE ${CaDiCaL_INCLUDE_DIR})
<< " See https://github.com/arminbiere/cadical for copyright "
<< "information.\n\n";
- if (Configuration::isBuiltWithAbc()
- || Configuration::isBuiltWithCryptominisat()
+ if (Configuration::isBuiltWithCryptominisat()
|| Configuration::isBuiltWithKissat()
|| Configuration::isBuiltWithEditline())
{
- if (Configuration::isBuiltWithAbc()) {
- ss << " ABC - A System for Sequential Synthesis and Verification\n"
- << " See http://bitbucket.org/alanmi/abc for copyright and\n"
- << " licensing information.\n\n";
- }
if (Configuration::isBuiltWithCryptominisat())
{
ss << " CryptoMiniSat - An Advanced SAT Solver\n"
return IS_GLPK_BUILD;
}
-bool Configuration::isBuiltWithAbc() {
- return IS_ABC_BUILD;
-}
-
bool Configuration::isBuiltWithCryptominisat() {
return IS_CRYPTOMINISAT_BUILD;
}
static bool isBuiltWithGlpk();
- static bool isBuiltWithAbc();
-
static bool isBuiltWithCryptominisat();
static bool isBuiltWithKissat();
# define IS_GLPK_BUILD false
#endif /* CVC5_USE_GLPK */
-#if CVC5_USE_ABC
-# define IS_ABC_BUILD true
-#else /* CVC5_USE_ABC */
-# define IS_ABC_BUILD false
-#endif /* CVC5_USE_ABC */
-
#if CVC5_USE_CRYPTOMINISAT
# define IS_CRYPTOMINISAT_BUILD true
#else /* CVC5_USE_CRYPTOMINISAT */
category = "expert"
long = "bv-sat-solver=MODE"
type = "SatSolverMode"
- default = "MINISAT"
+ default = "CADICAL"
predicates = ["checkBvSatSolver"]
help = "choose which sat solver to use, see --bv-sat-solver=help"
help_mode = "SAT solver for bit-blasting backend."
help_mode = "Bit-blasting modes."
[[option.mode.LAZY]]
name = "lazy"
- help = "Separate boolean structure and term reasoning between the core SAT solver and the bit-vector SAT solver."
+ help = "Separate Boolean structure and term reasoning between the core SAT solver and the bit-vector SAT solver."
[[option.mode.EAGER]]
name = "eager"
help = "Bitblast eagerly to bit-vector SAT solver."
-[[option]]
- name = "bitvectorAig"
- category = "regular"
- long = "bitblast-aig"
- type = "bool"
- default = "false"
- predicates = ["abcEnabledBuild", "setBitblastAig"]
- help = "bitblast by first converting to AIG (implies --bitblast=eager)"
-
-[[option]]
- name = "bitvectorAigSimplifications"
- category = "expert"
- long = "bv-aig-simp=COMMAND"
- type = "std::string"
- default = "\"balance;drw\""
- predicates = ["abcEnabledBuild"]
- help = "abc command to run AIG simplifications (implies --bitblast-aig, default is \"balance;drw\")"
-
[[option]]
name = "bitvectorPropagate"
category = "regular"
default = "true"
help = "use bit-vector propagation in the bit-blaster"
-[[option]]
- name = "bitvectorEqualitySolver"
- category = "regular"
- long = "bv-eq-solver"
- type = "bool"
- default = "true"
- help = "use the equality engine for the bit-vector theory (only if --bv-solver=layered)"
-
-[[option]]
- name = "bitvectorInequalitySolver"
- category = "regular"
- long = "bv-inequality-solver"
- type = "bool"
- default = "true"
- help = "turn on the inequality solver for the bit-vector theory (only if --bv-solver=layered)"
-
-[[option]]
- name = "bitvectorAlgebraicSolver"
- category = "expert"
- long = "bv-algebraic-solver"
- type = "bool"
- default = "false"
- help = "turn on experimental algebraic solver for the bit-vector theory (only if --bv-solver=layered)"
-
-[[option]]
- name = "bitvectorAlgebraicBudget"
- category = "expert"
- long = "bv-algebraic-budget=N"
- type = "uint64_t"
- default = "1500"
- help = "the budget allowed for the algebraic solver in number of SAT conflicts"
-
[[option]]
name = "bitvectorToBool"
category = "regular"
default = "false"
help = "enable rewrite pushing extract [i:0] over arithmetic operations (can blow up)"
-[[option]]
- name = "bvAbstraction"
- category = "undocumented"
- long = "bv-abstraction"
- type = "bool"
- default = "false"
- help = "mcm benchmark abstraction"
-
-[[option]]
- name = "skolemizeArguments"
- category = "undocumented"
- long = "bv-skolemize"
- type = "bool"
- default = "false"
- help = "skolemize arguments for bv abstraction (only does something if --bv-abstraction is on)"
-
-[[option]]
- name = "bvNumFunc"
- category = "expert"
- long = "bv-num-func=N"
- type = "uint64_t"
- default = "1"
- help = "number of function symbols in conflicts that are generalized"
-
-[[option]]
- name = "bvEagerExplanations"
- category = "expert"
- long = "bv-eager-explanations"
- type = "bool"
- default = "false"
- help = "compute bit-blasting propagation explanations eagerly"
-
-[[option]]
- name = "bitvectorQuickXplain"
- category = "expert"
- long = "bv-quick-xplain"
- type = "bool"
- default = "false"
- help = "minimize bv conflicts using the QuickXplain algorithm"
-
[[option]]
name = "bvIntroducePow2"
category = "expert"
[[option.mode.BITBLAST_INTERNAL]]
name = "bitblast-internal"
help = "Enables bitblasting to internal SAT solver with proof support."
-[[option.mode.LAYERED]]
- name = "layered"
- help = "Enables the layered BV solver."
[[option]]
name = "bvAssertInput"
default = "false"
help = "assert input assertions on user-level 0 instead of assuming them in the bit-vector SAT solver"
-
[[option]]
name = "rwExtendEq"
category = "expert"
--- /dev/null
+/******************************************************************************
+ * Top contributors (to current version):
+ * Kshitij Bansal, Tim King, Andrew Reynolds
+ *
+ * This file is part of the cvc5 project.
+ *
+ * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
+ * in the top-level source directory and their institutional affiliations.
+ * All rights reserved. See the file COPYING in the top-level source
+ * directory for licensing information.
+ * ****************************************************************************
+ *
+ * [[ Add one-line brief description here ]]
+ *
+ * [[ Add lengthier description here ]]
+ * \todo document this file
+ */
+
+// This is not built as a part of cvc5 and is not built by Makefile.am.
+// Compile: g++ didyoumean_test.cpp didyoumean.cpp
+// For debug compile with -DDIDYOUMEAN_DEBUG or -DDIDYOUMEAN_DEBUG1 or both
+
+#include "didyoumean.h"
+#include <iostream>
+
+using namespace std;
+using namespace cvc5;
+
+set<string> getDebugTags();
+set<string> getOptionStrings();
+
+int main() {
+ string a, b;
+
+ cin >> a;
+ cout << "Matches with debug tags:" << endl;
+ for (const string& s : DidYouMean(getDebugTags()).getMatch(a)) {
+ cout << s << endl;
+ }
+ cout << "Matches with option strings:" << endl;
+ for (const string& s : DidYouMean(getOptionStrings()).getMatch(a)) {
+ cout << s << endl;
+ }
+}
+
+set<string> getDebugTags() {
+ set<string> a;
+ a.insert("CDInsertHashMap");
+ a.insert("CDTrailHashMap");
+ a.insert("TrailHashMap");
+ a.insert("approx");
+ a.insert("approx::");
+ a.insert("approx::branch");
+ a.insert("approx::checkCutOnPad");
+ a.insert("approx::constraint");
+ a.insert("approx::gmi");
+ a.insert("approx::gmiCut");
+ a.insert("approx::guessIsConstructable");
+ a.insert("approx::lemmas");
+ a.insert("approx::mir");
+ a.insert("approx::mirCut");
+ a.insert("approx::nodelog");
+ a.insert("approx::replayAssert");
+ a.insert("approx::replayLogRec");
+ a.insert("approx::soi");
+ a.insert("approx::solveMIP");
+ a.insert("approx::sumConstraints");
+ a.insert("approx::vars");
+ a.insert("arith");
+ a.insert("arith::addSharedTerm");
+ a.insert("arith::approx::cuts");
+ a.insert("arith::arithvar");
+ a.insert("arith::asVectors");
+ a.insert("arith::bt");
+ a.insert("arith::collectModelInfo");
+ a.insert("arith::conflict");
+ a.insert("arith::congruenceManager");
+ a.insert("arith::congruences");
+ a.insert("arith::consistency");
+ a.insert("arith::consistency::comitonconflict");
+ a.insert("arith::consistency::final");
+ a.insert("arith::consistency::initial");
+ a.insert("arith::constraint");
+ a.insert("arith::dio");
+ a.insert("arith::dio::ex");
+ a.insert("arith::dio::max");
+ a.insert("arith::div");
+ a.insert("arith::dual");
+ a.insert("arith::ems");
+ a.insert("arith::eq");
+ a.insert("arith::error::mem");
+ a.insert("arith::explain");
+ a.insert("arith::explainNonbasics");
+ a.insert("arith::findModel");
+ a.insert("arith::focus");
+ a.insert("arith::hasIntegerModel");
+ a.insert("arith::importSolution");
+ a.insert("arith::ite");
+ a.insert("arith::ite::red");
+ a.insert("arith::learned");
+ a.insert("arith::lemma");
+ a.insert("arith::nf");
+ a.insert("arith::oldprop");
+ a.insert("arith::pivot");
+ a.insert("arith::preprocess");
+ a.insert("arith::preregister");
+ a.insert("arith::presolve");
+ a.insert("arith::print_assertions");
+ a.insert("arith::print_model");
+ a.insert("arith::prop");
+ a.insert("arith::resolveOutPropagated");
+ a.insert("arith::restart");
+ a.insert("arith::rewriter");
+ a.insert("arith::selectPrimalUpdate");
+ a.insert("arith::simplex:row");
+ a.insert("arith::solveInteger");
+ a.insert("arith::static");
+ a.insert("arith::subsumption");
+ a.insert("arith::tracking");
+ a.insert("arith::tracking::mid");
+ a.insert("arith::tracking::post");
+ a.insert("arith::tracking::pre");
+ a.insert("arith::unate");
+ a.insert("arith::unate::conf");
+ a.insert("arith::update");
+ a.insert("arith::update::select");
+ a.insert("arith::value");
+ a.insert("array-pf");
+ a.insert("array-types");
+ a.insert("arrays");
+ a.insert("arrays-model-based");
+ a.insert("arrays::propagate");
+ a.insert("arrays::sharing");
+ a.insert("attrgc");
+ a.insert("basicsAtBounds");
+ a.insert("bitvector");
+ a.insert("bitvector-bb");
+ a.insert("bitvector-bitblast");
+ a.insert("bitvector-expandDefinition");
+ a.insert("bitvector-model");
+ a.insert("bitvector-preregister");
+ a.insert("bitvector-rewrite");
+ a.insert("bitvector::bitblaster");
+ a.insert("bitvector::core");
+ a.insert("bitvector::explain");
+ a.insert("bitvector::propagate");
+ a.insert("bitvector::sharing");
+ a.insert("bool-flatten");
+ a.insert("bool-ite");
+ a.insert("boolean-terms");
+ a.insert("bt");
+ a.insert("builder");
+ a.insert("bv-bitblast");
+ a.insert("bv-core");
+ a.insert("bv-core-model");
+ a.insert("bv-inequality");
+ a.insert("bv-inequality-explain");
+ a.insert("bv-inequality-internal");
+ a.insert("bv-rewrite");
+ a.insert("bv-slicer");
+ a.insert("bv-slicer-eq");
+ a.insert("bv-slicer-uf");
+ a.insert("bv-subtheory-inequality");
+ a.insert("bv-to-bool");
+ a.insert("bva");
+ a.insert("cegqi");
+ a.insert("cegqi-debug");
+ a.insert("cegqi-prop-as-dec");
+ a.insert("cd_set_collection");
+ a.insert("cdlist");
+ a.insert("cdlist:cmm");
+ a.insert("cdqueue");
+ a.insert("check-inst");
+ a.insert("check-model::rep-checking");
+ a.insert("circuit-prop");
+ a.insert("cnf");
+ a.insert("constructInfeasiblityFunction");
+ a.insert("context");
+ a.insert("current");
+ a.insert("datatypes");
+ a.insert("datatypes-cycle-check");
+ a.insert("datatypes-cycles");
+ a.insert("datatypes-cycles-find");
+ a.insert("datatypes-debug");
+ a.insert("datatypes-explain");
+ a.insert("datatypes-gt");
+ a.insert("datatypes-inst");
+ a.insert("datatypes-labels");
+ a.insert("datatypes-output");
+ a.insert("datatypes-parametric");
+ a.insert("datatypes-prereg");
+ a.insert("datatypes-split");
+ a.insert("decision");
+ a.insert("decision::jh");
+ a.insert("determineArithVar");
+ a.insert("diamonds");
+ a.insert("dio::push");
+ a.insert("dt");
+ a.insert("dt-enum");
+ a.insert("dt-warn");
+ a.insert("dt::propagate");
+ a.insert("dualLike");
+ a.insert("effortlevel");
+ a.insert("ensureLiteral");
+ a.insert("eq");
+ a.insert("equality");
+ a.insert("equality::backtrack");
+ a.insert("equality::disequality");
+ a.insert("equality::evaluation");
+ a.insert("equality::graph");
+ a.insert("equality::internal");
+ a.insert("equality::trigger");
+ a.insert("equalsConstant");
+ a.insert("error");
+ a.insert("estimateWithCFE");
+ a.insert("expand");
+ a.insert("export");
+ a.insert("flipdec");
+ a.insert("fmc-entry-trie");
+ a.insert("fmc-interval-model-debug");
+ a.insert("fmf-card-debug");
+ a.insert("fmf-eval-debug");
+ a.insert("fmf-eval-debug2");
+ a.insert("fmf-exit");
+ a.insert("fmf-index-order");
+ a.insert("fmf-model-complete");
+ a.insert("fmf-model-cons");
+ a.insert("fmf-model-cons-debug");
+ a.insert("fmf-model-eval");
+ a.insert("fmf-model-prefs");
+ a.insert("fmf-model-req");
+ a.insert("focusDownToJust");
+ a.insert("focusDownToLastHalf");
+ a.insert("foo");
+ a.insert("gaussianElimConstructTableRow");
+ a.insert("gc");
+ a.insert("gc:leaks");
+ a.insert("getBestImpliedBound");
+ a.insert("getCeiling");
+ a.insert("getNewDomainValue");
+ a.insert("getPropagatedLiterals");
+ a.insert("getType");
+ a.insert("glpk::loadVB");
+ a.insert("guessCoefficientsConstructTableRow");
+ a.insert("guessIsConstructable");
+ a.insert("handleBorders");
+ a.insert("includeBoundUpdate");
+ a.insert("inst");
+ a.insert("inst-engine");
+ a.insert("inst-engine-ctrl");
+ a.insert("inst-engine-debug");
+ a.insert("inst-engine-phase-req");
+ a.insert("inst-engine-stuck");
+ a.insert("inst-fmf-ei");
+ a.insert("inst-match-gen");
+ a.insert("inst-trigger");
+ a.insert("integers");
+ a.insert("interactive");
+ a.insert("intersectConstantIte");
+ a.insert("isConst");
+ a.insert("ite");
+ a.insert("ite::atom");
+ a.insert("ite::constantIteEqualsConstant");
+ a.insert("ite::print-success");
+ a.insert("ite::simpite");
+ a.insert("lemma-ites");
+ a.insert("lemmaInputChannel");
+ a.insert("literal-matching");
+ a.insert("logPivot");
+ a.insert("matrix");
+ a.insert("minisat");
+ a.insert("minisat::lemmas");
+ a.insert("minisat::pop");
+ a.insert("minisat::remove-clause");
+ a.insert("minisat::search");
+ a.insert("miplib");
+ a.insert("model");
+ a.insert("model-getvalue");
+ a.insert("nf::tmp");
+ a.insert("nm");
+ a.insert("normal-form");
+ a.insert("options");
+ a.insert("paranoid:check_tableau");
+ a.insert("parser");
+ a.insert("parser-extra");
+ a.insert("parser-idt");
+ a.insert("parser-param");
+ a.insert("partial_model");
+ a.insert("pb");
+ a.insert("pipe");
+ a.insert("portfolio::outputmode");
+ a.insert("prec");
+ a.insert("preemptGetopt");
+ a.insert("proof:sat");
+ a.insert("proof:sat:detailed");
+ a.insert("prop");
+ a.insert("prop-explain");
+ a.insert("prop-value");
+ a.insert("prop::lemmas");
+ a.insert("propagateAsDecision");
+ a.insert("properConflict");
+ a.insert("qcf-ccbe");
+ a.insert("qcf-check-inst");
+ a.insert("qcf-eval");
+ a.insert("qcf-match");
+ a.insert("qcf-match-debug");
+ a.insert("qcf-nground");
+ a.insert("qint-check-debug2");
+ a.insert("qint-debug");
+ a.insert("qint-error");
+ a.insert("qint-model-debug");
+ a.insert("qint-model-debug2");
+ a.insert("qint-var-order-debug2");
+ a.insert("quant-arith");
+ a.insert("quant-arith-debug");
+ a.insert("quant-arith-simplex");
+ a.insert("quant-datatypes");
+ a.insert("quant-datatypes-debug");
+ a.insert("quant-req-phase");
+ a.insert("quant-uf-strategy");
+ a.insert("quantifiers");
+ a.insert("quantifiers-assert");
+ a.insert("quantifiers-check");
+ a.insert("quantifiers-dec");
+ a.insert("quantifiers-engine");
+ a.insert("quantifiers-flip");
+ a.insert("quantifiers-other");
+ a.insert("quantifiers-prereg");
+ a.insert("quantifiers-presolve");
+ a.insert("quantifiers-relevance");
+ a.insert("quantifiers-sat");
+ a.insert("quantifiers-substitute-debug");
+ a.insert("quantifiers::collectModelInfo");
+ a.insert("queueConditions");
+ a.insert("rationalToCfe");
+ a.insert("recentlyViolated");
+ a.insert("register");
+ a.insert("register::internal");
+ a.insert("relevant-trigger");
+ a.insert("removeFixed");
+ a.insert("rl");
+ a.insert("sat::minisat");
+ a.insert("selectFocusImproving");
+ a.insert("set_collection");
+ a.insert("sets");
+ a.insert("sets-assert");
+ a.insert("sets-checkmodel-ignore");
+ a.insert("sets-eq");
+ a.insert("sets-learn");
+ a.insert("sets-lemma");
+ a.insert("sets-model");
+ a.insert("sets-model-details");
+ a.insert("sets-parent");
+ a.insert("sets-pending");
+ a.insert("sets-prop");
+ a.insert("sets-prop-details");
+ a.insert("sets-scrutinize");
+ a.insert("sets-terminfo");
+ a.insert("shared");
+ a.insert("shared-terms-database");
+ a.insert("shared-terms-database::assert");
+ a.insert("sharing");
+ a.insert("simple-trigger");
+ a.insert("simplify");
+ a.insert("smart-multi-trigger");
+ a.insert("smt");
+ a.insert("soi::findModel");
+ a.insert("soi::selectPrimalUpdate");
+ a.insert("solveRealRelaxation");
+ a.insert("sort");
+ a.insert("speculativeUpdate");
+ a.insert("strings");
+ a.insert("strings-explain");
+ a.insert("strings-explain-debug");
+ a.insert("strings-prereg");
+ a.insert("strings-propagate");
+ a.insert("substitution");
+ a.insert("substitution::internal");
+ a.insert("tableau");
+ a.insert("te");
+ a.insert("term-db-cong");
+ a.insert("theory");
+ a.insert("theory::assertions");
+ a.insert("theory::atoms");
+ a.insert("theory::bv::rewrite");
+ a.insert("theory::conflict");
+ a.insert("theory::explain");
+ a.insert("theory::idl");
+ a.insert("theory::idl::model");
+ a.insert("theory::internal");
+ a.insert("theory::propagate");
+ a.insert("trans-closure");
+ a.insert("treat-unknown-error");
+ a.insert("tuprec");
+ a.insert("typecheck-idt");
+ a.insert("typecheck-q");
+ a.insert("typecheck-r");
+ a.insert("uf");
+ a.insert("uf-ss");
+ a.insert("uf-ss-check-region");
+ a.insert("uf-ss-cliques");
+ a.insert("uf-ss-debug");
+ a.insert("uf-ss-disequal");
+ a.insert("uf-ss-na");
+ a.insert("uf-ss-region");
+ a.insert("uf-ss-region-debug");
+ a.insert("uf-ss-register");
+ a.insert("uf-ss-sat");
+ a.insert("uf::propagate");
+ a.insert("uf::sharing");
+ a.insert("ufgc");
+ a.insert("ufsymm");
+ a.insert("ufsymm:clauses");
+ a.insert("ufsymm:eq");
+ a.insert("ufsymm:match");
+ a.insert("ufsymm:norm");
+ a.insert("ufsymm:p");
+ a.insert("update");
+ a.insert("updateAndSignal");
+ a.insert("weak");
+ a.insert("whytheoryenginewhy");
+ return a;
+}
+
+set<string> getOptionStrings() {
+ const char* cmdlineOptions[] = {
+ "lang",
+ "output-lang",
+ "language",
+ "output-language",
+ "verbose",
+ "quiet",
+ "stats",
+ "no-stats",
+ "statistics",
+ "no-statistics",
+ "stats-every-query",
+ "no-stats-every-query",
+ "statistics-every-query",
+ "no-statistics-every-query",
+ "parse-only",
+ "no-parse-only",
+ "preprocess-only",
+ "no-preprocess-only",
+ "trace",
+ "debug",
+ "print-success",
+ "no-print-success",
+ "smtlib-strict",
+ "default-expr-depth",
+ "default-dag-thresh",
+ "print-expr-types",
+ "eager-type-checking",
+ "lazy-type-checking",
+ "no-type-checking",
+ "biased-ites",
+ "no-biased-ites",
+ "boolean-term-conversion-mode",
+ "theoryof-mode",
+ "use-theory",
+ "bitblast-eager",
+ "no-bitblast-eager",
+ "bitblast-share-lemmas",
+ "no-bitblast-share-lemmas",
+ "bitblast-eager-fullcheck",
+ "no-bitblast-eager-fullcheck",
+ "bv-inequality-solver",
+ "no-bv-inequality-solver",
+ "bv-core-solver",
+ "no-bv-core-solver",
+ "bv-to-bool",
+ "no-bv-to-bool",
+ "bv-propagate",
+ "no-bv-propagate",
+ "bv-eq",
+ "no-bv-eq",
+ "dt-rewrite-error-sel",
+ "no-dt-rewrite-error-sel",
+ "dt-force-assignment",
+ "unate-lemmas",
+ "arith-prop",
+ "heuristic-pivots",
+ "standard-effort-variable-order-pivots",
+ "error-selection-rule",
+ "simplex-check-period",
+ "pivot-threshold",
+ "prop-row-length",
+ "disable-dio-solver",
+ "enable-arith-rewrite-equalities",
+ "disable-arith-rewrite-equalities",
+ "enable-miplib-trick",
+ "disable-miplib-trick",
+ "miplib-trick-subs",
+ "cut-all-bounded",
+ "no-cut-all-bounded",
+ "maxCutsInContext",
+ "revert-arith-models-on-unsat",
+ "no-revert-arith-models-on-unsat",
+ "fc-penalties",
+ "no-fc-penalties",
+ "use-fcsimplex",
+ "no-use-fcsimplex",
+ "use-soi",
+ "no-use-soi",
+ "restrict-pivots",
+ "no-restrict-pivots",
+ "collect-pivot-stats",
+ "no-collect-pivot-stats",
+ "use-approx",
+ "no-use-approx",
+ "approx-branch-depth",
+ "dio-decomps",
+ "no-dio-decomps",
+ "new-prop",
+ "no-new-prop",
+ "arith-prop-clauses",
+ "soi-qe",
+ "no-soi-qe",
+ "rewrite-divk",
+ "no-rewrite-divk",
+ "se-solve-int",
+ "no-se-solve-int",
+ "lemmas-on-replay-failure",
+ "no-lemmas-on-replay-failure",
+ "dio-turns",
+ "rr-turns",
+ "dio-repeat",
+ "no-dio-repeat",
+ "replay-early-close-depth",
+ "replay-num-err-penalty",
+ "replay-reject-cut",
+ "replay-lemma-reject-cut",
+ "replay-soi-major-threshold",
+ "replay-soi-major-threshold-pen",
+ "replay-soi-minor-threshold",
+ "replay-soi-minor-threshold-pen",
+ "symmetry-breaker",
+ "no-symmetry-breaker",
+ "condense-function-values",
+ "no-condense-function-values",
+ "disable-uf-ss-regions",
+ "uf-ss-eager-split",
+ "no-uf-ss-eager-split",
+ "uf-ss-totality",
+ "no-uf-ss-totality",
+ "uf-ss-totality-limited",
+ "uf-ss-totality-sym-break",
+ "no-uf-ss-totality-sym-break",
+ "uf-ss-abort-card",
+ "uf-ss-explained-cliques",
+ "no-uf-ss-explained-cliques",
+ "uf-ss-simple-cliques",
+ "no-uf-ss-simple-cliques",
+ "uf-ss-deq-prop",
+ "no-uf-ss-deq-prop",
+ "disable-uf-ss-min-model",
+ "uf-ss-clique-splits",
+ "no-uf-ss-clique-splits",
+ "uf-ss-sym-break",
+ "no-uf-ss-sym-break",
+ "uf-ss-fair",
+ "no-uf-ss-fair",
+ "arrays-optimize-linear",
+ "no-arrays-optimize-linear",
+ "arrays-lazy-rintro1",
+ "no-arrays-lazy-rintro1",
+ "arrays-model-based",
+ "no-arrays-model-based",
+ "arrays-eager-index",
+ "no-arrays-eager-index",
+ "arrays-eager-lemmas",
+ "no-arrays-eager-lemmas",
+ "disable-miniscope-quant",
+ "disable-miniscope-quant-fv",
+ "disable-prenex-quant",
+ "disable-var-elim-quant",
+ "disable-ite-lift-quant",
+ "cnf-quant",
+ "no-cnf-quant",
+ "clause-split",
+ "no-clause-split",
+ "pre-skolem-quant",
+ "no-pre-skolem-quant",
+ "ag-miniscope-quant",
+ "no-ag-miniscope-quant",
+ "macros-quant",
+ "no-macros-quant",
+ "fo-prop-quant",
+ "no-fo-prop-quant",
+ "disable-smart-triggers",
+ "relevant-triggers",
+ "no-relevant-triggers",
+ "relational-triggers",
+ "no-relational-triggers",
+ "register-quant-body-terms",
+ "no-register-quant-body-terms",
+ "inst-when",
+ "eager-inst-quant",
+ "no-eager-inst-quant",
+ "full-saturate-quant",
+ "no-full-saturate-quant",
+ "literal-matching",
+ "enable-cbqi",
+ "no-enable-cbqi",
+ "cegqi-recurse",
+ "no-cbqi-recurse",
+ "user-pat",
+ "flip-decision",
+ "disable-quant-internal-reps",
+ "finite-model-find",
+ "no-finite-model-find",
+ "mbqi",
+ "mbqi-one-inst-per-round",
+ "no-mbqi-one-inst-per-round",
+ "mbqi-one-quant-per-round",
+ "no-mbqi-one-quant-per-round",
+ "fmf-inst-engine",
+ "no-fmf-inst-engine",
+ "disable-fmf-inst-gen",
+ "fmf-inst-gen-one-quant-per-round",
+ "no-fmf-inst-gen-one-quant-per-round",
+ "fmf-fresh-dc",
+ "no-fmf-fresh-dc",
+ "disable-fmf-fmc-simple",
+ "fmf-bound-int",
+ "no-fmf-bound-int",
+ "axiom-inst",
+ "quant-cf",
+ "no-quant-cf",
+ "quant-cf-mode",
+ "quant-cf-when",
+ "rewrite-rules",
+ "no-rewrite-rules",
+ "rr-one-inst-per-round",
+ "no-rr-one-inst-per-round",
+ "strings-exp",
+ "no-strings-exp",
+ "strings-lb",
+ "strings-fmf",
+ "no-strings-fmf",
+ "strings-eit",
+ "no-strings-eit",
+ "strings-alphabet-card",
+ "show-sat-solvers",
+ "random-freq",
+ "random-seed",
+ "restart-int-base",
+ "restart-int-inc",
+ "refine-conflicts",
+ "no-refine-conflicts",
+ "minisat-elimination",
+ "no-minisat-elimination",
+ "minisat-dump-dimacs",
+ "no-minisat-dump-dimacs",
+ "model-format",
+ "dump",
+ "dump-to",
+ "force-logic",
+ "simplification",
+ "no-simplification",
+ "static-learning",
+ "no-static-learning",
+ "produce-models",
+ "no-produce-models",
+ "check-models",
+ "no-check-models",
+ "dump-models",
+ "no-dump-models",
+ "proof",
+ "no-proof",
+ "check-proofs",
+ "no-check-proofs",
+ "dump-proofs",
+ "no-dump-proofs",
+ "produce-unsat-cores",
+ "no-produce-unsat-cores",
+ "produce-assignments",
+ "no-produce-assignments",
+ "interactive",
+ "no-interactive",
+ "ite-simp",
+ "no-ite-simp",
+ "on-repeat-ite-simp",
+ "no-on-repeat-ite-simp",
+ "simp-with-care",
+ "no-simp-with-care",
+ "simp-ite-compress",
+ "no-simp-ite-compress",
+ "unconstrained-simp",
+ "no-unconstrained-simp",
+ "repeat-simp",
+ "no-repeat-simp",
+ "simp-ite-hunt-zombies",
+ "sort-inference",
+ "no-sort-inference",
+ "incremental",
+ "no-incremental",
+ "abstract-values",
+ "no-abstract-values",
+ "model-u-dt-enum",
+ "no-model-u-dt-enum",
+ "tlimit",
+ "tlimit-per",
+ "rlimit",
+ "rlimit-per",
+ "rewrite-apply-to-const",
+ "no-rewrite-apply-to-const",
+ "replay",
+ "replay-log",
+ "decision",
+ "decision-threshold",
+ "decision-use-weight",
+ "no-decision-use-weight",
+ "decision-random-weight",
+ "decision-weight-internal",
+ "version",
+ "license",
+ "help",
+ "show-config",
+ "show-debug-tags",
+ "show-trace-tags",
+ "early-exit",
+ "no-early-exit",
+ "threads",
+ "threadN",
+ "filter-lemma-length",
+ "fallback-sequential",
+ "no-fallback-sequential",
+ "incremental-parallel",
+ "no-incremental-parallel",
+ "no-interactive-prompt",
+ "immediate-exit",
+ "segv-spin",
+ "no-segv-spin",
+ "segv-nospin",
+ "wait-to-join",
+ "no-wait-to-join",
+ "strict-parsing",
+ "no-strict-parsing",
+ "mmap",
+ "no-mmap",
+ "no-checking",
+ "no-filesystem-access",
+ "no-include-file",
+ "enable-idl-rewrite-equalities",
+ "disable-idl-rewrite-equalities",
+ "sets-propagate",
+ "no-sets-propagate",
+ "sets-eager-lemmas",
+ "no-sets-eager-lemmas",
+ NULL,
+ }; /* cmdlineOptions */
+ int i = 0;
+ set<string> ret;
+ while (cmdlineOptions[i] != NULL) {
+ ret.insert(cmdlineOptions[i]);
+ i++;
+ }
+ return ret;
+}
d_options->base.resourceWeightHolder.emplace_back(optarg);
}
-void OptionsHandler::abcEnabledBuild(const std::string& flag, bool value)
-{
-#ifndef CVC5_USE_ABC
- if(value) {
- std::stringstream ss;
- ss << "option `" << flag
- << "' requires an abc-enabled build of cvc5; this binary was not built "
- "with abc support";
- throw OptionException(ss.str());
- }
-#endif /* CVC5_USE_ABC */
-}
-
-void OptionsHandler::abcEnabledBuild(const std::string& flag,
- const std::string& value)
-{
-#ifndef CVC5_USE_ABC
- if(!value.empty()) {
- std::stringstream ss;
- ss << "option `" << flag
- << "' requires an abc-enabled build of cvc5; this binary was not built "
- "with abc support";
- throw OptionException(ss.str());
- }
-#endif /* CVC5_USE_ABC */
-}
-
void OptionsHandler::checkBvSatSolver(const std::string& flag, SatSolverMode m)
{
if (m == SatSolverMode::CRYPTOMINISAT
std::cout << std::endl;
- print_config_cond("abc", Configuration::isBuiltWithAbc());
print_config_cond("cln", Configuration::isBuiltWithCln());
print_config_cond("glpk", Configuration::isBuiltWithGlpk());
print_config_cond("cryptominisat", Configuration::isBuiltWithCryptominisat());
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Mathias Preiner, Andrew Reynolds, Aina Niemetz
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * The BvAbstraction preprocessing pass.
- *
- * Abstract common structures over small domains to UF. This preprocessing
- * is particularly useful on QF_BV/mcm benchmarks and can be enabled via
- * option `--bv-abstraction`.
- * For more information see 3.4 Refactoring Isomorphic Circuits in [1].
- *
- * [1] Liana Hadarean, An Efficient and Trustworthy Theory Solver for
- * Bit-vectors in Satisfiability Modulo Theories
- * https://cs.nyu.edu/media/publications/hadarean_liana.pdf
- */
-
-#include "preprocessing/passes/bv_abstraction.h"
-
-#include <vector>
-
-#include "options/bv_options.h"
-#include "preprocessing/assertion_pipeline.h"
-#include "preprocessing/preprocessing_pass_context.h"
-#include "theory/bv/theory_bv.h"
-#include "theory/rewriter.h"
-#include "theory/theory_engine.h"
-
-namespace cvc5 {
-namespace preprocessing {
-namespace passes {
-
-using namespace cvc5::theory;
-
-BvAbstraction::BvAbstraction(PreprocessingPassContext* preprocContext)
- : PreprocessingPass(preprocContext, "bv-abstraction"){};
-
-PreprocessingPassResult BvAbstraction::applyInternal(
- AssertionPipeline* assertionsToPreprocess)
-{
- std::vector<Node> new_assertions;
- std::vector<Node> assertions(assertionsToPreprocess->begin(),
- assertionsToPreprocess->end());
- TheoryEngine* te = d_preprocContext->getTheoryEngine();
- bv::TheoryBV* bv_theory = static_cast<bv::TheoryBV*>(te->theoryOf(THEORY_BV));
- bv_theory->applyAbstraction(assertions, new_assertions);
- for (unsigned i = 0, size = assertionsToPreprocess->size(); i < size; ++i)
- {
- assertionsToPreprocess->replace(i, rewrite(new_assertions[i]));
- }
- return PreprocessingPassResult::NO_CONFLICT;
-}
-
-
-} // namespace passes
-} // namespace preprocessing
-} // namespace cvc5
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Mathias Preiner
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * The BvAbstraction preprocessing pass.
- *
- * Abstract common structures over small domains to UF. This preprocessing
- * is particularly useful on QF_BV/mcm benchmarks and can be enabled via
- * option `--bv-abstraction`.
- * For more information see 3.4 Refactoring Isomorphic Circuits in [1].
- *
- * [1] Liana Hadarean, An Efficient and Trustworthy Theory Solver for
- * Bit-vectors in Satisfiability Modulo Theories
- * https://cs.nyu.edu/media/publications/hadarean_liana.pdf
- */
-
-#include "cvc5_private.h"
-
-#ifndef CVC5__PREPROCESSING__PASSES__BV_ABSTRACTION_H
-#define CVC5__PREPROCESSING__PASSES__BV_ABSTRACTION_H
-
-#include "preprocessing/preprocessing_pass.h"
-
-namespace cvc5 {
-namespace preprocessing {
-namespace passes {
-
-class BvAbstraction : public PreprocessingPass
-{
- public:
- BvAbstraction(PreprocessingPassContext* preprocContext);
-
- protected:
- PreprocessingPassResult applyInternal(
- AssertionPipeline* assertionsToPreprocess) override;
-};
-
-} // namespace passes
-} // namespace preprocessing
-} // namespace cvc5
-
-#endif /* CVC5__PREPROCESSING__PASSES__BV_ABSTRACTION_H */
#include "preprocessing/passes/ackermann.h"
#include "preprocessing/passes/apply_substs.h"
#include "preprocessing/passes/bool_to_bv.h"
-#include "preprocessing/passes/bv_abstraction.h"
#include "preprocessing/passes/bv_eager_atoms.h"
#include "preprocessing/passes/bv_gauss.h"
#include "preprocessing/passes/bv_intro_pow2.h"
registerPassInfo("sort-inference", callCtor<SortInferencePass>);
registerPassInfo("sep-skolem-emp", callCtor<SepSkolemEmp>);
registerPassInfo("rewrite", callCtor<Rewrite>);
- registerPassInfo("bv-abstraction", callCtor<BvAbstraction>);
registerPassInfo("bv-eager-atoms", callCtor<BvEagerAtoms>);
registerPassInfo("pseudo-boolean-processor",
callCtor<PseudoBooleanProcessor>);
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Alex Ozdemir, Mathias Preiner
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * The interface for things that want to recieve notification from the SAT
- * solver.
- */
-
-#include "cvc5_private.h"
-
-#ifndef CVC5__PROP__BVSATSOLVERNOTIFY_H
-#define CVC5__PROP__BVSATSOLVERNOTIFY_H
-
-#include "prop/sat_solver_types.h"
-#include "util/resource_manager.h"
-
-namespace cvc5 {
-namespace prop {
-
-class BVSatSolverNotify {
-public:
-
- virtual ~BVSatSolverNotify() {};
-
- /**
- * If the notify returns false, the solver will break out of whatever it's currently doing
- * with an "unknown" answer.
- */
- virtual bool notify(SatLiteral lit) = 0;
-
- /**
- * Notify about a learnt clause.
- */
- virtual void notify(SatClause& clause) = 0;
- virtual void spendResource(Resource r) = 0;
- virtual void safePoint(Resource r) = 0;
-
-};/* class BVSatSolverInterface::Notify */
-
-}
-} // namespace cvc5
-
-#endif
+++ /dev/null
-MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
- Copyright (c) 2007-2010 Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+++ /dev/null
-================================================================================
-DIRECTORY OVERVIEW:
-
-mtl/ Mini Template Library
-utils/ Generic helper code (I/O, Parsing, CPU-time, etc)
-core/ A core version of the solver
-simp/ An extended solver with simplification capabilities
-README
-LICENSE
-
-================================================================================
-BUILDING: (release version: without assertions, statically linked, etc)
-
-export MROOT=<minisat-dir> (or setenv in cshell)
-cd { core | simp }
-gmake rs
-cp minisat_static <install-dir>/minisat
-
-================================================================================
-EXAMPLES:
-
-Run minisat with same heuristics as version 2.0:
-
-> minisat <cnf-file> -no-luby -rinc=1.5 -phase-saving=0 -rnd-freq=0.02
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Dejan Jovanovic, Tim King
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * SAT Solver.
- *
- * Implementation of the minisat for cvc5 (bit-vectors).
- */
-
-#include "prop/bvminisat/bvminisat.h"
-
-#include "prop/bvminisat/simp/SimpSolver.h"
-#include "proof/clause_id.h"
-#include "util/statistics_registry.h"
-
-namespace cvc5 {
-namespace prop {
-
-BVMinisatSatSolver::BVMinisatSatSolver(StatisticsRegistry& registry,
- context::Context* mainSatContext,
- const std::string& name)
- : context::ContextNotifyObj(mainSatContext, false),
- d_minisat(new BVMinisat::SimpSolver(mainSatContext)),
- d_minisatNotify(nullptr),
- d_assertionsCount(0),
- d_assertionsRealCount(mainSatContext, 0),
- d_lastPropagation(mainSatContext, 0),
- d_statistics(registry, name)
-{
- d_statistics.init(d_minisat.get());
-}
-
-BVMinisatSatSolver::~BVMinisatSatSolver() { d_statistics.deinit(); }
-
-void BVMinisatSatSolver::MinisatNotify::notify(
- BVMinisat::vec<BVMinisat::Lit>& clause)
-{
- SatClause satClause;
- for (unsigned i = 0, n = clause.size(); i < n; ++i)
- {
- satClause.push_back(toSatLiteral(clause[i]));
- }
- d_notify->notify(satClause);
-}
-
-void BVMinisatSatSolver::setNotify(BVSatSolverNotify* notify) {
- d_minisatNotify.reset(new MinisatNotify(notify));
- d_minisat->setNotify(d_minisatNotify.get());
-}
-
-ClauseId BVMinisatSatSolver::addClause(SatClause& clause,
- bool removable) {
- Debug("sat::minisat") << "Add clause " << clause <<"\n";
- BVMinisat::vec<BVMinisat::Lit> minisat_clause;
- toMinisatClause(clause, minisat_clause);
- // for(unsigned i = 0; i < minisat_clause.size(); ++i) {
- // d_minisat->setFrozen(BVMinisat::var(minisat_clause[i]), true);
- // }
- ClauseId clause_id = ClauseIdError;
- d_minisat->addClause(minisat_clause, clause_id);
- return clause_id;
-}
-
-SatValue BVMinisatSatSolver::propagate() {
- return toSatLiteralValue(d_minisat->propagateAssumptions());
-}
-
-void BVMinisatSatSolver::addMarkerLiteral(SatLiteral lit) {
- d_minisat->addMarkerLiteral(BVMinisat::var(toMinisatLit(lit)));
- markUnremovable(lit);
-}
-
-void BVMinisatSatSolver::explain(SatLiteral lit, std::vector<SatLiteral>& explanation) {
- std::vector<BVMinisat::Lit> minisat_explanation;
- d_minisat->explain(toMinisatLit(lit), minisat_explanation);
- for (unsigned i = 0; i < minisat_explanation.size(); ++i) {
- explanation.push_back(toSatLiteral(minisat_explanation[i]));
- }
-}
-
-SatValue BVMinisatSatSolver::assertAssumption(SatLiteral lit, bool propagate) {
- d_assertionsCount ++;
- d_assertionsRealCount = d_assertionsRealCount + 1;
- return toSatLiteralValue(d_minisat->assertAssumption(toMinisatLit(lit), propagate));
-}
-
-void BVMinisatSatSolver::contextNotifyPop() {
- while (d_assertionsCount > d_assertionsRealCount) {
- popAssumption();
- d_assertionsCount --;
- }
-}
-
-void BVMinisatSatSolver::popAssumption() {
- d_minisat->popAssumption();
-}
-
-SatVariable BVMinisatSatSolver::newVar(bool isTheoryAtom, bool preRegister, bool canErase){
- return d_minisat->newVar(true, true, !canErase);
-}
-
-void BVMinisatSatSolver::markUnremovable(SatLiteral lit){
- d_minisat->setFrozen(BVMinisat::var(toMinisatLit(lit)), true);
-}
-
-
-void BVMinisatSatSolver::interrupt(){
- d_minisat->interrupt();
-}
-
-SatValue BVMinisatSatSolver::solve()
-{
- TimerStat::CodeTimer solveTimer(d_statistics.d_statSolveTime);
- ++d_statistics.d_statCallsToSolve;
- return toSatLiteralValue(d_minisat->solve());
-}
-
-SatValue BVMinisatSatSolver::solve(long unsigned int& resource){
- Trace("limit") << "MinisatSatSolver::solve(): have limit of " << resource << " conflicts" << std::endl;
- TimerStat::CodeTimer solveTimer(d_statistics.d_statSolveTime);
- ++d_statistics.d_statCallsToSolve;
- if(resource == 0) {
- d_minisat->budgetOff();
- } else {
- d_minisat->setConfBudget(resource);
- }
- // BVMinisat::vec<BVMinisat::Lit> empty;
- unsigned long conflictsBefore = d_minisat->conflicts;
- SatValue result = toSatLiteralValue(d_minisat->solveLimited());
- d_minisat->clearInterrupt();
- resource = d_minisat->conflicts - conflictsBefore;
- Trace("limit") << "<MinisatSatSolver::solve(): it took " << resource << " conflicts" << std::endl;
- return result;
-}
-
-bool BVMinisatSatSolver::ok() const { return d_minisat->okay(); }
-
-void BVMinisatSatSolver::getUnsatCore(SatClause& unsatCore) {
- // TODO add assertion to check the call was after an unsat call
- for (int i = 0; i < d_minisat->conflict.size(); ++i) {
- unsatCore.push_back(toSatLiteral(d_minisat->conflict[i]));
- }
-}
-
-SatValue BVMinisatSatSolver::value(SatLiteral l){
- return toSatLiteralValue(d_minisat->value(toMinisatLit(l)));
-}
-
-SatValue BVMinisatSatSolver::modelValue(SatLiteral l){
- return toSatLiteralValue(d_minisat->modelValue(toMinisatLit(l)));
-}
-
-void BVMinisatSatSolver::unregisterVar(SatLiteral lit) {
- // this should only be called when user context is implemented
- // in the BVSatSolver
- Unreachable();
-}
-
-void BVMinisatSatSolver::renewVar(SatLiteral lit, int level) {
- // this should only be called when user context is implemented
- // in the BVSatSolver
-
- Unreachable();
-}
-
-unsigned BVMinisatSatSolver::getAssertionLevel() const {
- // we have no user context implemented so far
- return 0;
-}
-
-// converting from internal Minisat representation
-
-SatVariable BVMinisatSatSolver::toSatVariable(BVMinisat::Var var) {
- if (var == var_Undef) {
- return undefSatVariable;
- }
- return SatVariable(var);
-}
-
-BVMinisat::Lit BVMinisatSatSolver::toMinisatLit(SatLiteral lit) {
- if (lit == undefSatLiteral) {
- return BVMinisat::lit_Undef;
- }
- return BVMinisat::mkLit(lit.getSatVariable(), lit.isNegated());
-}
-
-SatLiteral BVMinisatSatSolver::toSatLiteral(BVMinisat::Lit lit) {
- if (lit == BVMinisat::lit_Undef) {
- return undefSatLiteral;
- }
-
- return SatLiteral(SatVariable(BVMinisat::var(lit)),
- BVMinisat::sign(lit));
-}
-
-SatValue BVMinisatSatSolver::toSatLiteralValue(BVMinisat::lbool res) {
- if(res == (BVMinisat::lbool((uint8_t)0))) return SAT_VALUE_TRUE;
- if(res == (BVMinisat::lbool((uint8_t)2))) return SAT_VALUE_UNKNOWN;
- Assert(res == (BVMinisat::lbool((uint8_t)1)));
- return SAT_VALUE_FALSE;
-}
-
-void BVMinisatSatSolver::toMinisatClause(SatClause& clause,
- BVMinisat::vec<BVMinisat::Lit>& minisat_clause) {
- for (unsigned i = 0; i < clause.size(); ++i) {
- minisat_clause.push(toMinisatLit(clause[i]));
- }
- Assert(clause.size() == (unsigned)minisat_clause.size());
-}
-
-void BVMinisatSatSolver::toSatClause(const BVMinisat::Clause& clause,
- SatClause& sat_clause) {
- for (int i = 0; i < clause.size(); ++i) {
- sat_clause.push_back(toSatLiteral(clause[i]));
- }
- Assert((unsigned)clause.size() == sat_clause.size());
-}
-
-
-// Satistics for BVMinisatSatSolver
-
-BVMinisatSatSolver::Statistics::Statistics(StatisticsRegistry& registry,
- const std::string& prefix)
- : d_statStarts(
- registry.registerReference<int64_t>(prefix + "bvminisat::starts")),
- d_statDecisions(
- registry.registerReference<int64_t>(prefix + "bvminisat::decisions")),
- d_statRndDecisions(registry.registerReference<int64_t>(
- prefix + "bvminisat::rnd_decisions")),
- d_statPropagations(registry.registerReference<int64_t>(
- prefix + "bvminisat::propagations")),
- d_statConflicts(
- registry.registerReference<int64_t>(prefix + "bvminisat::conflicts")),
- d_statClausesLiterals(registry.registerReference<int64_t>(
- prefix + "bvminisat::clauses_literals")),
- d_statLearntsLiterals(registry.registerReference<int64_t>(
- prefix + "bvminisat::learnts_literals")),
- d_statMaxLiterals(registry.registerReference<int64_t>(
- prefix + "bvminisat::max_literals")),
- d_statTotLiterals(registry.registerReference<int64_t>(
- prefix + "bvminisat::tot_literals")),
- d_statEliminatedVars(registry.registerReference<int64_t>(
- prefix + "bvminisat::eliminated_vars")),
- d_statCallsToSolve(
- registry.registerInt(prefix + "bvminisat::calls_to_solve")),
- d_statSolveTime(registry.registerTimer(prefix + "bvminisat::solve_time"))
-{
- if (!d_registerStats)
- {
- return;
- }
-}
-
-void BVMinisatSatSolver::Statistics::init(BVMinisat::SimpSolver* minisat){
- if (!d_registerStats){
- return;
- }
-
- d_statStarts.set(minisat->starts);
- d_statDecisions.set(minisat->decisions);
- d_statRndDecisions.set(minisat->rnd_decisions);
- d_statPropagations.set(minisat->propagations);
- d_statConflicts.set(minisat->conflicts);
- d_statClausesLiterals.set(minisat->clauses_literals);
- d_statLearntsLiterals.set(minisat->learnts_literals);
- d_statMaxLiterals.set(minisat->max_literals);
- d_statTotLiterals.set(minisat->tot_literals);
- d_statEliminatedVars.set(minisat->eliminated_vars);
-}
-
-void BVMinisatSatSolver::Statistics::deinit()
-{
- if (!d_registerStats)
- {
- return;
- }
-
- d_statStarts.reset();
- d_statDecisions.reset();
- d_statRndDecisions.reset();
- d_statPropagations.reset();
- d_statConflicts.reset();
- d_statClausesLiterals.reset();
- d_statLearntsLiterals.reset();
- d_statMaxLiterals.reset();
- d_statTotLiterals.reset();
- d_statEliminatedVars.reset();
-}
-
-} // namespace prop
-} // namespace cvc5
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Mathias Preiner, Liana Hadarean, Tim King
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * SAT Solver.
- *
- * Implementation of the minisat for cvc5 (bit-vectors).
- */
-
-#include "cvc5_private.h"
-
-#pragma once
-
-#include <memory>
-
-#include "context/cdo.h"
-#include "prop/bv_sat_solver_notify.h"
-#include "prop/bvminisat/simp/SimpSolver.h"
-#include "prop/sat_solver.h"
-#include "util/resource_manager.h"
-#include "util/statistics_stats.h"
-
-namespace cvc5 {
-namespace prop {
-
-class BVMinisatSatSolver : public BVSatSolverInterface,
- public context::ContextNotifyObj
-{
- private:
- class MinisatNotify : public BVMinisat::Notify
- {
- BVSatSolverNotify* d_notify;
-
- public:
- MinisatNotify(BVSatSolverNotify* notify) : d_notify(notify) {}
- bool notify(BVMinisat::Lit lit) override
- {
- return d_notify->notify(toSatLiteral(lit));
- }
- void notify(BVMinisat::vec<BVMinisat::Lit>& clause) override;
- void spendResource(Resource r) override
- {
- d_notify->spendResource(r);
- }
- void safePoint(Resource r) override
- {
- d_notify->safePoint(r);
- }
- };
-
- std::unique_ptr<BVMinisat::SimpSolver> d_minisat;
- std::unique_ptr<MinisatNotify> d_minisatNotify;
-
- unsigned d_assertionsCount;
- context::CDO<unsigned> d_assertionsRealCount;
- context::CDO<unsigned> d_lastPropagation;
-
-protected:
- void contextNotifyPop() override;
-
-public:
- BVMinisatSatSolver(StatisticsRegistry& registry,
- context::Context* mainSatContext,
- const std::string& name = "");
- virtual ~BVMinisatSatSolver();
-
- void setNotify(BVSatSolverNotify* notify) override;
-
- ClauseId addClause(SatClause& clause, bool removable) override;
-
- ClauseId addXorClause(SatClause& clause, bool rhs, bool removable) override
- {
- Unreachable() << "Minisat does not support native XOR reasoning";
- return ClauseIdError;
- }
-
- SatValue propagate() override;
-
- SatVariable newVar(bool isTheoryAtom = false,
- bool preRegister = false,
- bool canErase = true) override;
-
- SatVariable trueVar() override { return d_minisat->trueVar(); }
- SatVariable falseVar() override { return d_minisat->falseVar(); }
-
- void markUnremovable(SatLiteral lit) override;
-
- void interrupt() override;
-
- SatValue solve() override;
- SatValue solve(long unsigned int&) override;
- bool ok() const override;
- void getUnsatCore(SatClause& unsatCore) override;
-
- SatValue value(SatLiteral l) override;
- SatValue modelValue(SatLiteral l) override;
-
- void unregisterVar(SatLiteral lit);
- void renewVar(SatLiteral lit, int level = -1);
- unsigned getAssertionLevel() const override;
-
- // helper methods for converting from the internal Minisat representation
-
- static SatVariable toSatVariable(BVMinisat::Var var);
- static BVMinisat::Lit toMinisatLit(SatLiteral lit);
- static SatLiteral toSatLiteral(BVMinisat::Lit lit);
- static SatValue toSatLiteralValue(BVMinisat::lbool res);
-
- static void toMinisatClause(SatClause& clause, BVMinisat::vec<BVMinisat::Lit>& minisat_clause);
- static void toSatClause (const BVMinisat::Clause& clause, SatClause& sat_clause);
- void addMarkerLiteral(SatLiteral lit) override;
-
- void explain(SatLiteral lit, std::vector<SatLiteral>& explanation) override;
-
- SatValue assertAssumption(SatLiteral lit, bool propagate) override;
-
- void popAssumption() override;
-
- private:
- /* Disable the default constructor. */
- BVMinisatSatSolver() = delete;
-
- class Statistics {
- public:
- ReferenceStat<int64_t> d_statStarts, d_statDecisions;
- ReferenceStat<int64_t> d_statRndDecisions, d_statPropagations;
- ReferenceStat<int64_t> d_statConflicts, d_statClausesLiterals;
- ReferenceStat<int64_t> d_statLearntsLiterals, d_statMaxLiterals;
- ReferenceStat<int64_t> d_statTotLiterals;
- ReferenceStat<int64_t> d_statEliminatedVars;
- IntStat d_statCallsToSolve;
- TimerStat d_statSolveTime;
- bool d_registerStats = true;
- Statistics(StatisticsRegistry& registry, const std::string& prefix);
- void init(BVMinisat::SimpSolver* minisat);
- void deinit();
- };
-
- Statistics d_statistics;
-};
-
-} // namespace prop
-} // namespace cvc5
+++ /dev/null
-/****************************************************************************************[Dimacs.h]
-Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_Dimacs_h
-#define BVMinisat_Dimacs_h
-
-#include <stdio.h>
-
-#include "prop/bvminisat/core/SolverTypes.h"
-#include "prop/bvminisat/utils/ParseUtils.h"
-
-namespace cvc5 {
-namespace BVMinisat {
-
-//=================================================================================================
-// DIMACS Parser:
-
-template<class B, class Solver>
-static void readClause(B& in, Solver& S, vec<Lit>& lits) {
- int parsed_lit, var;
- lits.clear();
- for (;;){
- parsed_lit = parseInt(in);
- if (parsed_lit == 0) break;
- var = abs(parsed_lit)-1;
- while (var >= S.nVars()) S.newVar();
- lits.push( (parsed_lit > 0) ? mkLit(var) : ~mkLit(var) );
- }
-}
-
-template<class B, class Solver>
-static void parse_DIMACS_main(B& in, Solver& S) {
- vec<Lit> lits;
- int vars = 0;
- int clauses = 0;
- int cnt = 0;
- for (;;){
- skipWhitespace(in);
- if (*in == EOF) break;
- else if (*in == 'p'){
- if (eagerMatch(in, "p cnf")){
- vars = parseInt(in);
- clauses = parseInt(in);
- // SATRACE'06 hack
- // if (clauses > 4000000)
- // S.eliminate(true);
- }else{
- printf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
- }
- } else if (*in == 'c' || *in == 'p')
- skipLine(in);
- else{
- cnt++;
- readClause(in, S, lits);
- S.addClause_(lits); }
- }
- if (vars != S.nVars())
- fprintf(stderr, "WARNING! DIMACS header mismatch: wrong number of variables.\n");
- if (cnt != clauses)
- fprintf(stderr, "WARNING! DIMACS header mismatch: wrong number of clauses.\n");
-}
-
-// Inserts problem into solver.
-//
-template<class Solver>
-static void parse_DIMACS(gzFile input_stream, Solver& S) {
- StreamBuffer in(input_stream);
- parse_DIMACS_main(in, S); }
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/***************************************************************************************[Solver.cc]
-Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#include "prop/bvminisat/core/Solver.h"
-
-#include <math.h>
-
-#include <iostream>
-#include <vector>
-
-#include "base/check.h"
-#include "base/exception.h"
-#include "base/output.h"
-#include "options/bv_options.h"
-#include "options/smt_options.h"
-#include "prop/bvminisat/mtl/Sort.h"
-#include "theory/interrupted.h"
-#include "util/utility.h"
-
-namespace cvc5 {
-namespace BVMinisat {
-
-#define OUTPUT_TAG "bvminisat: [a=" << assumptions.size() << ",l=" << decisionLevel() << "] "
-
-std::ostream& operator << (std::ostream& out, const BVMinisat::Lit& l) {
- out << (sign(l) ? "-" : "") << var(l) + 1;
- return out;
-}
-
-std::ostream& operator << (std::ostream& out, const BVMinisat::Clause& c) {
- for (int i = 0; i < c.size(); i++) {
- if (i > 0) {
- out << " ";
- }
- out << c[i];
- }
- return out;
-}
-
-
-//=================================================================================================
-// Options:
-
-
-static const char* _cat = "CORE";
-
-static DoubleOption opt_var_decay (_cat, "var-decay", "The variable activity decay factor", 0.95, DoubleRange(0, false, 1, false));
-static DoubleOption opt_clause_decay (_cat, "cla-decay", "The clause activity decay factor", 0.999, DoubleRange(0, false, 1, false));
-static DoubleOption opt_random_var_freq (_cat, "rnd-freq", "The frequency with which the decision heuristic tries to choose a random variable", 0, DoubleRange(0, true, 1, true));
-static DoubleOption opt_random_seed (_cat, "rnd-seed", "Used by the random variable selection", 91648253, DoubleRange(0, false, HUGE_VAL, false));
-static IntOption opt_ccmin_mode (_cat, "ccmin-mode", "Controls conflict clause minimization (0=none, 1=basic, 2=deep)", 2, IntRange(0, 2));
-static IntOption opt_phase_saving (_cat, "phase-saving", "Controls the level of phase saving (0=none, 1=limited, 2=full)", 2, IntRange(0, 2));
-static BoolOption opt_rnd_init_act (_cat, "rnd-init", "Randomize the initial activity", false);
-static BoolOption opt_luby_restart (_cat, "luby", "Use the Luby restart sequence", true);
-static IntOption opt_restart_first (_cat, "rfirst", "The base restart interval", 25, IntRange(1, INT32_MAX));
-static DoubleOption opt_restart_inc (_cat, "rinc", "Restart interval increase factor", 3, DoubleRange(1, false, HUGE_VAL, false));
-static DoubleOption opt_garbage_frac (_cat, "gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered", 0.20, DoubleRange(0, false, HUGE_VAL, false));
-
-//=================================================================================================
-// Proof declarations
-CRef Solver::TCRef_Undef = CRef_Undef;
-CRef Solver::TCRef_Lazy = CRef_Undef - 1; // no real lazy ref here
-
-
-//=================================================================================================
-// Constructor/Destructor:
-
-Solver::Solver(cvc5::context::Context* context)
- :
-
- // Parameters (user settable):
- //
- d_notify(nullptr),
- c(context),
- verbosity(0),
- var_decay(opt_var_decay),
- clause_decay(opt_clause_decay),
- random_var_freq(opt_random_var_freq),
- random_seed(opt_random_seed),
- luby_restart(opt_luby_restart),
- ccmin_mode(opt_ccmin_mode),
- phase_saving(opt_phase_saving),
- rnd_pol(false),
- rnd_init_act(opt_rnd_init_act),
- garbage_frac(opt_garbage_frac),
- restart_first(opt_restart_first),
- restart_inc(opt_restart_inc)
-
- // Parameters (the rest):
- //
- ,
- learntsize_factor((double)1 / (double)3),
- learntsize_inc(1.5)
-
- // Parameters (experimental):
- //
- ,
- learntsize_adjust_start_confl(100),
- learntsize_adjust_inc(1.5)
-
- // Statistics: (formerly in 'SolverStats')
- //
- ,
- solves(0),
- starts(0),
- decisions(0),
- rnd_decisions(0),
- propagations(0),
- conflicts(0),
- dec_vars(0),
- clauses_literals(0),
- learnts_literals(0),
- max_literals(0),
- tot_literals(0)
-
- ,
- need_to_propagate(false),
- only_bcp(false),
- clause_added(false),
- ok(true),
- cla_inc(1),
- var_inc(1),
- watches(WatcherDeleted(ca)),
- qhead(0),
- simpDB_assigns(-1),
- simpDB_props(0),
- order_heap(VarOrderLt(activity)),
- progress_estimate(0),
- remove_satisfied(true)
-
- ,
- ca()
-
- // even though these are temporaries and technically should be set
- // before calling, lets initialize them. this will reduces chances of
- // non-determinism in portfolio (parallel) solver if variables are
- // being (incorrectly) used without initialization.
- ,
- seen(),
- analyze_stack(),
- analyze_toclear(),
- add_tmp(),
- max_learnts(0.0),
- learntsize_adjust_confl(0.0),
- learntsize_adjust_cnt(0)
-
- // Resource constraints:
- //
- ,
- conflict_budget(-1),
- propagation_budget(-1),
- asynch_interrupt(false)
-{
- // Create the constant variables
- varTrue = newVar(true, false);
- varFalse = newVar(false, false);
-
- // Assert the constants
- uncheckedEnqueue(mkLit(varTrue, false));
- uncheckedEnqueue(mkLit(varFalse, true));
-}
-
-
-Solver::~Solver()
-{
-}
-
-
-//=================================================================================================
-// Minor methods:
-
-
-// Creates a new SAT variable in the solver. If 'decision' is cleared, variable will not be
-// used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result).
-//
-Var Solver::newVar(bool sign, bool dvar)
-{
- int v = nVars();
- watches .init(mkLit(v, false));
- watches .init(mkLit(v, true ));
- assigns .push(l_Undef);
- vardata .push(mkVarData(CRef_Undef, 0));
- marker .push(0);
- //activity .push(0);
- activity .push(rnd_init_act ? drand(random_seed) * 0.00001 : 0);
- seen .push(0);
- polarity .push(sign);
- decision .push();
- trail .capacity(v+1);
- setDecisionVar(v, dvar);
-
- return v;
-}
-
-
-bool Solver::addClause_(vec<Lit>& ps, ClauseId& id)
-{
- if (decisionLevel() > 0) {
- cancelUntil(0);
- }
-
- if (!ok) {
- id = ClauseIdUndef;
- return false;
- }
-
- // Check if clause is satisfied and remove false/duplicate literals:
- // TODO proof for duplicate literals removal?
- sort(ps);
- Lit p; int i, j;
- int falseLiteralsCount = 0;
-
- for (i = j = 0, p = lit_Undef; i < ps.size(); i++) {
- // tautologies are ignored
- if (value(ps[i]) == l_True || ps[i] == ~p) {
- id = ClauseIdUndef;
- return true;
- }
-
- // Ignore repeated literals
- if (ps[i] == p) {
- continue;
- }
-
- if (value(ps[i]) == l_False) {
- continue;
- }
- ps[j++] = p = ps[i];
- }
-
- ps.shrink(i - j);
-
- clause_added = true;
-
- if(falseLiteralsCount == 0) {
- if (ps.size() == 0) {
- return ok = false;
- }
- else if (ps.size() == 1){
- uncheckedEnqueue(ps[0]);
- CRef confl_ref = propagate();
- ok = (confl_ref == CRef_Undef);
- return ok;
- } else {
- CRef cr = ca.alloc(ps, false);
- clauses.push(cr);
- attachClause(cr);
- }
- return ok;
- }
- return ok;
-}
-
-void Solver::attachClause(CRef cr) {
- const Clause& clause = ca[cr];
- Assert(clause.size() > 1);
- watches[~clause[0]].push(Watcher(cr, clause[1]));
- watches[~clause[1]].push(Watcher(cr, clause[0]));
- if (clause.learnt())
- learnts_literals += clause.size();
- else
- clauses_literals += clause.size();
-}
-
-void Solver::detachClause(CRef cr, bool strict) {
- const Clause& clause = ca[cr];
-
- Assert(clause.size() > 1);
-
- if (strict)
- {
- remove(watches[~clause[0]], Watcher(cr, clause[1]));
- remove(watches[~clause[1]], Watcher(cr, clause[0]));
- }else{
- // Lazy detaching: (NOTE! Must clean all watcher lists before garbage collecting this clause)
- watches.smudge(~clause[0]);
- watches.smudge(~clause[1]);
- }
-
- if (clause.learnt())
- learnts_literals -= clause.size();
- else
- clauses_literals -= clause.size();
-}
-
-void Solver::removeClause(CRef cr) {
- Clause& clause = ca[cr];
- detachClause(cr);
- // Don't leave pointers to free'd memory!
- if (locked(clause)) vardata[var(clause[0])].reason = CRef_Undef;
- clause.mark(1);
- ca.free(cr);
-}
-
-bool Solver::satisfied(const Clause& clause) const
-{
- for (int i = 0; i < clause.size(); i++)
- if (value(clause[i]) == l_True) return true;
- return false;
-}
-
-// Revert to the state at given level (keeping all assignment at 'level' but not beyond).
-//
-void Solver::cancelUntil(int level) {
- if (decisionLevel() > level){
- Debug("bvminisat::explain") << OUTPUT_TAG << " backtracking to " << level << std::endl;
- for (int clause = trail.size() - 1; clause >= trail_lim[level]; clause--)
- {
- Var x = var(trail[clause]);
- assigns[x] = l_Undef;
- if (marker[x] == 2) marker[x] = 1;
- if (phase_saving > 1
- || ((phase_saving == 1) && clause > trail_lim.last()))
- {
- polarity[x] = sign(trail[clause]);
- }
- insertVarOrder(x);
- }
- qhead = trail_lim[level];
- trail.shrink(trail.size() - trail_lim[level]);
- trail_lim.shrink(trail_lim.size() - level);
- }
-}
-
-
-//=================================================================================================
-// Major methods:
-
-
-Lit Solver::pickBranchLit()
-{
- Var next = var_Undef;
-
- // Random decision:
- if (drand(random_seed) < random_var_freq && !order_heap.empty()){
- next = order_heap[irand(random_seed,order_heap.size())];
- if (value(next) == l_Undef && decision[next])
- rnd_decisions++; }
-
- // Activity based decision:
- while (next == var_Undef || value(next) != l_Undef || !decision[next])
- if (order_heap.empty()){
- next = var_Undef;
- break;
- }else
- next = order_heap.removeMin();
-
- return next == var_Undef ? lit_Undef : mkLit(next, rnd_pol ? drand(random_seed) < 0.5 : polarity[next]);
-}
-
-/*_________________________________________________________________________________________________
-|
-| analyze : (confl : Clause*) (out_learnt : vec<Lit>&) (out_btlevel : int&) ->
-[void]
-|
-| Description:
-| Analyze conflict and produce a reason clause.
-|
-| Pre-conditions:
-| * 'out_learnt' is assumed to be cleared.
-| * Current decision level must be greater than root level.
-|
-| Post-conditions:
-| * 'out_learnt[0]' is the asserting literal at level 'out_btlevel'.
-| * If out_learnt.size() > 1 then 'out_learnt[1]' has the greatest decision
-level of the | rest of literals. There may be others from the same level
-though.
-|
-|________________________________________________________________________________________________@*/
-void Solver::analyze(CRef confl, vec<Lit>& out_learnt, int& out_btlevel, UIP uip)
-{
- int pathC = 0;
- Lit p = lit_Undef;
-
- // Generate conflict clause:
- //
- out_learnt.push(); // (leave room for the asserting literal)
- int index = trail.size() - 1;
-
- bool done = false;
-
- do{
- Assert(confl != CRef_Undef); // (otherwise should be UIP)
- Clause& clause = ca[confl];
-
- if (clause.learnt()) claBumpActivity(clause);
-
- for (int j = (p == lit_Undef) ? 0 : 1; j < clause.size(); j++)
- {
- Lit q = clause[j];
-
- if (!seen[var(q)] && level(var(q)) > 0)
- {
- varBumpActivity(var(q));
- seen[var(q)] = 1;
- if (level(var(q)) >= decisionLevel())
- pathC++;
- else
- out_learnt.push(q);
- }
- }
-
- // Select next clause to look at:
- while (!seen[var(trail[index--])]);
- p = trail[index+1];
- confl = reason(var(p));
- seen[var(p)] = 0;
- pathC--;
-
- switch (uip) {
- case UIP_FIRST:
- done = pathC == 0;
- break;
- case UIP_LAST:
- done = confl == CRef_Undef || (pathC == 0 && marker[var(p)] == 2);
- break;
- default:
- Unreachable();
- break;
- }
- } while (!done);
- out_learnt[0] = ~p;
-
- // Simplify conflict clause:
- //
- int i1, j;
- out_learnt.copyTo(analyze_toclear);
- if (ccmin_mode == 2){
- uint32_t abstract_level = 0;
- for (i1 = 1; i1 < out_learnt.size(); i1++)
- abstract_level |= abstractLevel(
- var(out_learnt[i1])); // (maintain an abstraction of levels
- // involved in conflict)
-
- for (i1 = j = 1; i1 < out_learnt.size(); i1++)
- {
- if (reason(var(out_learnt[i1])) == CRef_Undef)
- {
- out_learnt[j++] = out_learnt[i1];
- }
- else
- {
- // Check if the literal is redundant
- if (!litRedundant(out_learnt[i1], abstract_level))
- {
- // Literal is not redundant
- out_learnt[j++] = out_learnt[i1];
- }
- }
- }
- }else if (ccmin_mode == 1){
- Unreachable();
- for (i1 = j = 1; i1 < out_learnt.size(); i1++)
- {
- Var x = var(out_learnt[i1]);
-
- if (reason(x) == CRef_Undef)
- out_learnt[j++] = out_learnt[i1];
- else
- {
- Clause& clause = ca[reason(var(out_learnt[i1]))];
- for (int k = 1; k < clause.size(); k++)
- if (!seen[var(clause[k])] && level(var(clause[k])) > 0)
- {
- out_learnt[j++] = out_learnt[i1];
- break;
- }
- }
- }
- }else
- i1 = j = out_learnt.size();
-
- max_literals += out_learnt.size();
- out_learnt.shrink(i1 - j);
- tot_literals += out_learnt.size();
-
- for (int i2 = 0; i2 < out_learnt.size(); ++i2)
- {
- if (marker[var(out_learnt[i2])] == 0)
- {
- break;
- }
- }
-
- // Find correct backtrack level:
- //
- if (out_learnt.size() == 1) {
- out_btlevel = 0;
- }
- else{
- int max_i = 1;
- // Find the first literal assigned at the next-highest level:
- for (int i3 = 2; i3 < out_learnt.size(); i3++)
- if (level(var(out_learnt[i3])) > level(var(out_learnt[max_i])))
- max_i = i3;
- // Swap-in this literal at i1 1:
- Lit p2 = out_learnt[max_i];
- out_learnt[max_i] = out_learnt[1];
- out_learnt[1] = p2;
- out_btlevel = level(var(p2));
- }
-
- for (int j2 = 0; j2 < analyze_toclear.size(); j2++)
- seen[var(analyze_toclear[j2])] = 0; // ('seen[]' is now cleared)
-}
-
-
-// Check if 'p' can be removed. 'abstract_levels' is used to abort early if the algorithm is
-// visiting literals at levels that cannot be removed later.
-bool Solver::litRedundant(Lit p, uint32_t abstract_levels)
-{
- analyze_stack.clear(); analyze_stack.push(p);
- int top = analyze_toclear.size();
- while (analyze_stack.size() > 0){
- CRef c_reason = reason(var(analyze_stack.last()));
- Assert(c_reason != CRef_Undef);
- Clause& clause = ca[c_reason];
- int c_size = clause.size();
- analyze_stack.pop();
-
- for (int i = 1; i < c_size; i++){
- Lit p2 = clause[i];
- if (!seen[var(p2)] && level(var(p2)) > 0)
- {
- if (reason(var(p2)) != CRef_Undef
- && (abstractLevel(var(p2)) & abstract_levels) != 0)
- {
- seen[var(p2)] = 1;
- analyze_stack.push(p2);
- analyze_toclear.push(p2);
- }
- else
- {
- for (int j = top; j < analyze_toclear.size(); j++)
- seen[var(analyze_toclear[j])] = 0;
- analyze_toclear.shrink(analyze_toclear.size() - top);
- return false;
- }
- }
- }
- }
-
- return true;
-}
-
-/**
- * Specialized analyzeFinal procedure where we test the consistency
- * of the assumptions before backtracking bellow the assumption level.
- *
- * @param p the original uip (may be unit)
- * @param confl_clause the conflict clause
- * @param out_conflict the conflict in terms of assumptions we are building
- */
-void Solver::analyzeFinal2(Lit p, CRef confl_clause, vec<Lit>& out_conflict) {
- Assert(confl_clause != CRef_Undef);
- Assert(decisionLevel() == assumptions.size());
- Assert(level(var(p)) == assumptions.size());
-
- out_conflict.clear();
-
- Clause& cl = ca[confl_clause];
- for (int i = 0; i < cl.size(); ++i) {
- seen[var(cl[i])] = 1;
- }
-
- int end = trail_lim[0];
- for (int i = trail.size() - 1; i >= end; i--) {
- Var x = var(trail[i]);
- if (seen[x]) {
- if (reason(x) == CRef_Undef) {
- // we skip p if was a learnt unit
- if (x != var(p)) {
- if (marker[x] == 2) {
- Assert(level(x) > 0);
- out_conflict.push(~trail[i]);
- }
- }
- } else {
- Clause& clause = ca[reason(x)];
-
- for (int j = 1; j < clause.size(); j++)
- {
- if (level(var(clause[j])) > 0) seen[var(clause[j])] = 1;
- }
- }
- seen[x] = 0;
- }
- Assert(seen[x] == 0);
- }
- Assert(out_conflict.size());
-}
-
-/*_________________________________________________________________________________________________
-|
-| analyzeFinal : (p : Lit) -> [void]
-|
-| Description:
-| Specialized analysis procedure to express the final conflict in terms of
-assumptions. | Calculates the (possibly empty) set of assumptions that led to
-the assignment of 'p', and | stores the result in 'out_conflict'.
-|________________________________________________________________________________________________@*/
-void Solver::analyzeFinal(Lit p, vec<Lit>& out_conflict)
-{
- out_conflict.clear();
- if (marker[var(p)] == 2) {
- out_conflict.push(p);
- }
-
- if (decisionLevel() == 0)
- {
- return;
- }
-
- seen[var(p)] = 1;
- int end = trail_lim[0];
-
- for (int i = trail.size()-1; i >= end; i--){
- Var x = var(trail[i]);
- if (seen[x]) {
- if (reason(x) == CRef_Undef) {
- Assert(marker[x] == 2);
- Assert(level(x) > 0);
- if (~trail[i] != p)
- {
- out_conflict.push(~trail[i]);
- }
- } else {
- Clause& clause = ca[reason(x)];
- for (int j = 1; j < clause.size(); j++)
- {
- if (level(var(clause[j])) > 0)
- {
- seen[var(clause[j])] = 1;
- }
- }
- }
- seen[x] = 0;
- }
- }
-
- seen[var(p)] = 0;
- Assert(out_conflict.size());
-}
-
-
-void Solver::uncheckedEnqueue(Lit p, CRef from)
-{
- Assert(value(p) == l_Undef);
- assigns[var(p)] = lbool(!sign(p));
- vardata[var(p)] = mkVarData(from, decisionLevel());
- trail.push_(p);
- if (decisionLevel() <= assumptions.size() && marker[var(p)] == 1)
- {
- if (d_notify)
- {
- Debug("bvminisat::explain")
- << OUTPUT_TAG << "propagating " << p << std::endl;
- d_notify->notify(p);
- }
- }
-}
-
-void Solver::popAssumption() {
- assumptions.pop();
- conflict.clear();
- cancelUntil(assumptions.size());
-}
-
-lbool Solver::propagateAssumptions() {
- only_bcp = true;
- ccmin_mode = 0;
- return search(-1);
-}
-
-lbool Solver::assertAssumption(Lit p, bool propagate) {
- // TODO need to somehow mark the assumption as unit in the current context?
- // it's not always unit though, but this would be useful for debugging
-
- // Assert(marker[var(p)] == 1);
-
- if (decisionLevel() > assumptions.size()) {
- cancelUntil(assumptions.size());
- }
-
- conflict.clear();
-
- // add to the assumptions
- if (c->getLevel() > 0) {
- assumptions.push(p);
- } else {
- ClauseId id;
- if (!addClause(p, id)) {
- conflict.push(~p);
- return l_False;
- }
- }
-
- // run the propagation
- if (propagate) {
- only_bcp = true;
- ccmin_mode = 0;
- lbool result = search(-1);
- return result;
- } else {
- return l_True;
- }
-}
-
-void Solver::addMarkerLiteral(Var var) {
- // make sure it wasn't already marked
- Assert(marker[var] == 0);
- marker[var] = 1;
-}
-
-/*_________________________________________________________________________________________________
-|
-| propagate : [void] -> [Clause*]
-|
-| Description:
-| Propagates all enqueued facts. If a conflict arises, the conflicting clause
-is returned, | otherwise CRef_Undef.
-|
-| Post-conditions:
-| * the propagation queue is empty, even if there was a conflict.
-|________________________________________________________________________________________________@*/
-CRef Solver::propagate()
-{
- CRef confl = CRef_Undef;
- int num_props = 0;
- watches.cleanAll();
-
- while (qhead < trail.size()){
- Lit p = trail[qhead++]; // 'p' is enqueued fact to propagate.
- vec<Watcher>& ws = watches[p];
- Watcher *i, *j, *end;
- num_props++;
-
- for (i = j = (Watcher*)ws, end = i + ws.size(); i != end;){
- // Try to avoid inspecting the clause:
- Lit blocker = i->blocker;
- if (value(blocker) == l_True){
- *j++ = *i++; continue; }
-
- // Make sure the false literal is data[1]:
- CRef cr = i->cref;
- Clause& clause = ca[cr];
- Lit false_lit = ~p;
- if (clause[0] == false_lit)
- clause[0] = clause[1], clause[1] = false_lit;
- Assert(clause[1] == false_lit);
- i++;
-
- // If 0th watch is true, then clause is already satisfied.
- Lit first = clause[0];
- Watcher w = Watcher(cr, first);
- if (first != blocker && value(first) == l_True){
- *j++ = w; continue; }
-
- // Look for new watch:
- for (int k = 2; k < clause.size(); k++)
- if (value(clause[k]) != l_False)
- {
- clause[1] = clause[k];
- clause[k] = false_lit;
- watches[~clause[1]].push(w);
- goto NextClause;
- }
-
- // Did not find watch -- clause is unit under assignment:
- *j++ = w;
- if (value(first) == l_False){
- confl = cr;
- qhead = trail.size();
- // Copy the remaining watches:
- while (i < end)
- *j++ = *i++;
- }else
- uncheckedEnqueue(first, cr);
-
- NextClause:;
- }
- ws.shrink(i - j);
- }
- propagations += num_props;
- simpDB_props -= num_props;
-
- return confl;
-}
-
-/*_________________________________________________________________________________________________
-|
-| reduceDB : () -> [void]
-|
-| Description:
-| Remove half of the learnt clauses, minus the clauses locked by the current
-assignment. Locked | clauses are clauses that are reason to some assignment.
-Binary clauses are never removed.
-|________________________________________________________________________________________________@*/
-struct reduceDB_lt
-{
- ClauseAllocator& ca;
- reduceDB_lt(ClauseAllocator& ca_) : ca(ca_) {}
- bool operator()(CRef x, CRef y)
- {
- return ca[x].size() > 2
- && (ca[y].size() == 2 || ca[x].activity() < ca[y].activity());
- }
-};
-void Solver::reduceDB()
-{
- int i, j;
- double extra_lim = cla_inc / learnts.size(); // Remove any clause below this activity
-
- sort(learnts, reduceDB_lt(ca));
- // Don't delete binary or locked clauses. From the rest, delete clauses from the first half
- // and clauses with activity smaller than 'extra_lim':
- for (i = j = 0; i < learnts.size(); i++){
- Clause& clause = ca[learnts[i]];
- if (clause.size() > 2 && !locked(clause)
- && (i < learnts.size() / 2 || clause.activity() < extra_lim))
- removeClause(learnts[i]);
- else
- learnts[j++] = learnts[i];
- }
- learnts.shrink(i - j);
- checkGarbage();
-}
-
-
-void Solver::removeSatisfied(vec<CRef>& cs)
-{
- int i, j;
- for (i = j = 0; i < cs.size(); i++){
- Clause& clause = ca[cs[i]];
- if (satisfied(clause))
- {
- removeClause(cs[i]);
- }
- else
- cs[j++] = cs[i];
- }
- cs.shrink(i - j);
-}
-
-
-void Solver::rebuildOrderHeap()
-{
- vec<Var> vs;
- for (Var v = 0; v < nVars(); v++)
- if (decision[v] && value(v) == l_Undef)
- vs.push(v);
- order_heap.build(vs);
-}
-
-/*_________________________________________________________________________________________________
-|
-| simplify : [void] -> [bool]
-|
-| Description:
-| Simplify the clause database according to the current top-level assigment.
-Currently, the only | thing done here is the removal of satisfied clauses,
-but more things can be put here.
-|________________________________________________________________________________________________@*/
-bool Solver::simplify()
-{
- Assert(decisionLevel() == 0);
-
- if (!ok || propagate() != CRef_Undef) return ok = false;
-
- if (nAssigns() == simpDB_assigns || (simpDB_props > 0)) return true;
-
- d_notify->spendResource(Resource::BvSatSimplifyStep);
-
- // Remove satisfied clauses:
- removeSatisfied(learnts);
- if (remove_satisfied) // Can be turned off.
- removeSatisfied(clauses);
- checkGarbage();
- rebuildOrderHeap();
-
- simpDB_assigns = nAssigns();
- simpDB_props =
- clauses_literals + learnts_literals; // (shouldn't depend on stats
- // really, but it will do for now)
-
- return true;
-}
-
-/*_________________________________________________________________________________________________
-|
-| search : (nof_conflicts : int) (params : const SearchParams&) -> [lbool]
-|
-| Description:
-| Search for a model the specified number of conflicts.
-| NOTE! Use negative value for 'nof_conflicts' indicate infinity.
-|
-| Output:
-| 'l_True' if a partial assigment that is consistent with respect to the
-clauseset is found. If | all variables are decision variables, this means
-that the clause set is satisfiable. 'l_False' | if the clause set is
-unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached.
-|________________________________________________________________________________________________@*/
-lbool Solver::search(int nof_conflicts, UIP uip)
-{
- Assert(ok);
- int backtrack_level;
- int conflictC = 0;
- vec<Lit> learnt_clause;
- starts++;
-
- for (;;)
- {
- d_notify->safePoint(Resource::BvSatPropagateStep);
- CRef confl = propagate();
- if (confl != CRef_Undef)
- {
- // CONFLICT
- conflicts++;
- conflictC++;
-
- if (decisionLevel() == 0)
- {
- // can this happen for bv?
- return l_False;
- }
-
- learnt_clause.clear();
- analyze(confl, learnt_clause, backtrack_level, uip);
-
- Lit p = learnt_clause[0];
- // bool assumption = marker[var(p)] == 2;
-
- CRef cr = CRef_Undef;
- if (learnt_clause.size() > 1)
- {
- cr = ca.alloc(learnt_clause, true);
- learnts.push(cr);
- attachClause(cr);
- claBumpActivity(ca[cr]);
- }
-
- if (learnt_clause.size() == 1)
- {
- // learning a unit clause
- }
-
- // if the uip was an assumption we are unsat
- if (level(var(p)) <= assumptions.size())
- {
- for (int i = 0; i < learnt_clause.size(); ++i)
- {
- Assert(level(var(learnt_clause[i])) <= decisionLevel());
- seen[var(learnt_clause[i])] = 1;
- }
-
- analyzeFinal(p, conflict);
- Debug("bvminisat::search")
- << OUTPUT_TAG << " conflict on assumptions " << std::endl;
- return l_False;
- }
-
- if (!cvc5::options::bvEagerExplanations())
- {
- // check if uip leads to a conflict
- if (backtrack_level < assumptions.size())
- {
- cancelUntil(assumptions.size());
- uncheckedEnqueue(p, cr);
-
- CRef new_confl = propagate();
- if (new_confl != CRef_Undef)
- {
- // we have a conflict we now need to explain it
- analyzeFinal2(p, new_confl, conflict);
- return l_False;
- }
- }
- }
-
- cancelUntil(backtrack_level);
- uncheckedEnqueue(p, cr);
-
- varDecayActivity();
- claDecayActivity();
-
- if (--learntsize_adjust_cnt == 0)
- {
- learntsize_adjust_confl *= learntsize_adjust_inc;
- learntsize_adjust_cnt = (int)learntsize_adjust_confl;
- max_learnts *= learntsize_inc;
-
- if (verbosity >= 1)
- printf("| %9d | %7d %8d %8d | %8d %8d %6.0f | %6.3f %% |\n",
- (int)conflicts,
- (int)dec_vars
- - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]),
- nClauses(),
- (int)clauses_literals,
- (int)max_learnts,
- nLearnts(),
- (double)learnts_literals / nLearnts(),
- progressEstimate() * 100);
- }
- }
- else
- {
- // NO CONFLICT
- bool isWithinBudget;
- try
- {
- isWithinBudget =
- withinBudget(Resource::BvSatConflictsStep);
- }
- catch (const cvc5::theory::Interrupted& e)
- {
- // do some clean-up and rethrow
- cancelUntil(assumptions.size());
- throw e;
- }
-
- if ((decisionLevel() > assumptions.size() && nof_conflicts >= 0
- && conflictC >= nof_conflicts)
- || !isWithinBudget)
- {
- // Reached bound on number of conflicts:
- Debug("bvminisat::search") << OUTPUT_TAG << " restarting " << std::endl;
- progress_estimate = progressEstimate();
- cancelUntil(assumptions.size());
- return l_Undef;
- }
-
- // Simplify the set of problem clauses:
- if (decisionLevel() == 0 && !simplify())
- {
- Debug("bvminisat::search")
- << OUTPUT_TAG << " base level conflict, we're unsat" << std::endl;
- return l_False;
- }
-
- // We can't erase clauses if there is unprocessed assumptions, there might
- // be some propagationg we need to redu
- if (decisionLevel() >= assumptions.size()
- && learnts.size() - nAssigns() >= max_learnts)
- {
- // Reduce the set of learnt clauses:
- Debug("bvminisat::search")
- << OUTPUT_TAG << " cleaning up database" << std::endl;
- reduceDB();
- }
-
- Lit next = lit_Undef;
- while (decisionLevel() < assumptions.size())
- {
- // Perform user provided assumption:
- Lit p = assumptions[decisionLevel()];
- if (value(p) == l_True)
- {
- // Dummy decision level:
- newDecisionLevel();
- }
- else if (value(p) == l_False)
- {
- marker[var(p)] = 2;
-
- analyzeFinal(~p, conflict);
- Debug("bvminisat::search")
- << OUTPUT_TAG << " assumption false, we're unsat" << std::endl;
- return l_False;
- }
- else
- {
- marker[var(p)] = 2;
- next = p;
- break;
- }
- }
-
- if (next == lit_Undef)
- {
- if (only_bcp)
- {
- Debug("bvminisat::search")
- << OUTPUT_TAG << " only bcp, skipping rest of the problem"
- << std::endl;
- return l_True;
- }
-
- // New variable decision:
- decisions++;
- next = pickBranchLit();
-
- if (next == lit_Undef)
- {
- Debug("bvminisat::search")
- << OUTPUT_TAG << " satisfiable" << std::endl;
- // Model found:
- return l_True;
- }
- }
-
- // Increase decision level and enqueue 'next'
- newDecisionLevel();
- uncheckedEnqueue(next);
- }
- }
-}
-
-
-double Solver::progressEstimate() const
-{
- double progress = 0;
- double F = 1.0 / nVars();
-
- for (int i = 0; i <= decisionLevel(); i++){
- int beg = i == 0 ? 0 : trail_lim[i - 1];
- int end = i == decisionLevel() ? trail.size() : trail_lim[i];
- progress += pow(F, i) * (end - beg);
- }
-
- return progress / nVars();
-}
-
-/*
- Finite subsequences of the Luby-sequence:
-
- 0: 1
- 1: 1 1 2
- 2: 1 1 2 1 1 2 4
- 3: 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8
- ...
-
-
- */
-
-static double luby(double y, int x){
-
- // Find the finite subsequence that contains index 'x', and the
- // size of that subsequence:
- int size, seq;
- for (size = 1, seq = 0; size < x+1; seq++, size = 2*size+1);
-
- while (size-1 != x){
- size = (size-1)>>1;
- seq--;
- x = x % size;
- }
-
- return pow(y, seq);
-}
-
-// NOTE: assumptions passed in member-variable 'assumptions'.
-lbool Solver::solve_()
-{
- Debug("bvminisat") <<"BVMinisat::Solving learned clauses " << learnts.size() <<"\n";
- Debug("bvminisat") <<"BVMinisat::Solving assumptions " << assumptions.size() <<"\n";
-
- model.clear();
- conflict.clear();
-
- ccmin_mode = 0;
-
- if (!ok) return l_False;
-
- solves++;
-
- max_learnts = nClauses() * learntsize_factor;
- learntsize_adjust_confl = learntsize_adjust_start_confl;
- learntsize_adjust_cnt = (int)learntsize_adjust_confl;
- lbool status = l_Undef;
-
- if (verbosity >= 1){
- printf("============================[ Search Statistics ]==============================\n");
- printf("| Conflicts | ORIGINAL | LEARNT | Progress |\n");
- printf("| | Vars Clauses Literals | Limit Clauses Lit/Cl | |\n");
- printf("===============================================================================\n");
- }
-
- // Search:
- int curr_restarts = 0;
- while (status == l_Undef){
- double rest_base = luby_restart ? luby(restart_inc, curr_restarts) : pow(restart_inc, curr_restarts);
- status = search(rest_base * restart_first);
- if (!withinBudget(Resource::BvSatConflictsStep)) break;
- curr_restarts++;
- }
-
- if (verbosity >= 1)
- printf("===============================================================================\n");
-
- if (status == l_True){
- // Extend & copy model:
- // model.growTo(nVars());
- // for (int i = 0; i < nVars(); i++) model[i] = value(i);
- }else if (status == l_False && conflict.size() == 0)
- ok = false;
-
- return status;
-}
-
-//=================================================================================================
-// Bitvector propagations
-//
-
-void Solver::explain(Lit p, std::vector<Lit>& explanation) {
- Debug("bvminisat::explain") << OUTPUT_TAG << "starting explain of " << p << std::endl;
-
- // top level fact, no explanation necessary
- if (level(var(p)) == 0) {
- return;
- }
-
- seen[var(p)] = 1;
-
- // if we are called at decisionLevel = 0 trail_lim is empty
- int bottom = trail_lim[0];
- for (int i = trail.size()-1; i >= bottom; i--){
- Var x = var(trail[i]);
- if (seen[x]) {
- if (reason(x) == CRef_Undef) {
- if (marker[x] == 2) {
- Assert(level(x) > 0);
- explanation.push_back(trail[i]);
- } else {
- Assert(level(x) == 0);
- }
- } else {
- Clause& clause = ca[reason(x)];
- for (int j = 1; j < clause.size(); j++)
- {
- if (level(var(clause[j])) > 0)
- {
- seen[var(clause[j])] = 1;
- }
- }
- }
- seen[x] = 0;
- }
- }
- seen[var(p)] = 0;
-}
-
-//=================================================================================================
-// Writing CNF to DIMACS:
-//
-// FIXME: this needs to be rewritten completely.
-
-static Var mapVar(Var x, vec<Var>& map, Var& max)
-{
- if (map.size() <= x || map[x] == -1){
- map.growTo(x+1, -1);
- map[x] = max++;
- }
- return map[x];
-}
-
-void Solver::toDimacs(FILE* f, Clause& clause, vec<Var>& map, Var& max)
-{
- if (satisfied(clause)) return;
-
- for (int i = 0; i < clause.size(); i++)
- if (value(clause[i]) != l_False)
- fprintf(f,
- "%s%d ",
- sign(clause[i]) ? "-" : "",
- mapVar(var(clause[i]), map, max) + 1);
- fprintf(f, "0\n");
-}
-
-
-void Solver::toDimacs(const char *file, const vec<Lit>& assumps)
-{
- FILE* f = fopen(file, "wr");
- if (f == NULL)
- fprintf(stderr, "could not open file %s\n", file), exit(1);
- toDimacs(f, assumps);
- fclose(f);
-}
-
-
-void Solver::toDimacs(FILE* f, const vec<Lit>& assumps)
-{
- // Handle case when solver is in contradictory state:
- if (!ok){
- fprintf(f, "p cnf 1 2\n1 0\n-1 0\n");
- return; }
-
- vec<Var> map; Var max = 0;
-
- // Cannot use removeClauses here because it is not safe
- // to deallocate them at this point. Could be improved.
- int cnt = 0;
- for (int i = 0; i < clauses.size(); i++)
- if (!satisfied(ca[clauses[i]]))
- cnt++;
-
- for (int i = 0; i < clauses.size(); i++)
- if (!satisfied(ca[clauses[i]])){
- Clause& clause = ca[clauses[i]];
- for (int j = 0; j < clause.size(); j++)
- if (value(clause[j]) != l_False) mapVar(var(clause[j]), map, max);
- }
-
- // Assumptions are added as unit clauses:
- cnt += assumps.size();
-
- fprintf(f, "p cnf %d %d\n", max, cnt);
-
- for (int i = 0; i < assumps.size(); i++){
- Assert(value(assumps[i]) != l_False);
- fprintf(f,
- "%s%d 0\n",
- sign(assumps[i]) ? "-" : "",
- mapVar(var(assumps[i]), map, max) + 1);
- }
-
- for (int i = 0; i < clauses.size(); i++)
- toDimacs(f, ca[clauses[i]], map, max);
-
- if (verbosity > 0)
- printf("Wrote %d clauses with %d variables.\n", cnt, max);
-}
-
-
-//=================================================================================================
-// Garbage Collection methods:
-
-void Solver::relocAll(ClauseAllocator& to)
-{
- // All watchers:
- //
- // for (int i = 0; i < watches.size(); i++)
- watches.cleanAll();
- for (int v = 0; v < nVars(); v++)
- for (int s = 0; s < 2; s++){
- Lit p = mkLit(v, s);
- // printf(" >>> RELOCING: %s%d\n", sign(p)?"-":"", var(p)+1);
- vec<Watcher>& ws = watches[p];
- for (int j = 0; j < ws.size(); j++) ca.reloc(ws[j].cref, to);
- }
-
- // All reasons:
- //
- for (int i = 0; i < trail.size(); i++){
- Var v = var(trail[i]);
-
- if (reason(v) != CRef_Undef && (ca[reason(v)].reloced() || locked(ca[reason(v)])))
- ca.reloc(vardata[v].reason, to);
- }
-
- // All learnt:
- //
- for (int i = 0; i < learnts.size(); i++) ca.reloc(learnts[i], to);
-
- // All original:
- //
- for (int i = 0; i < clauses.size(); i++) ca.reloc(clauses[i], to);
-}
-
-
-void Solver::garbageCollect()
-{
- // Initialize the next region to a size corresponding to the estimated utilization degree. This
- // is not precise but should avoid some unnecessary reallocations for the new region:
- ClauseAllocator to(ca.size() - ca.wasted());
- Debug("bvminisat") << " BVMinisat::Garbage collection \n";
- relocAll(to);
- if (verbosity >= 2)
- printf(
- "| Garbage collection: %12d bytes => %12d bytes |\n",
- ca.size() * ClauseAllocator::Unit_Size,
- to.size() * ClauseAllocator::Unit_Size);
- to.moveTo(ca);
-}
-
-void ClauseAllocator::reloc(CRef& cr, ClauseAllocator& to)
-{
- Clause& c = operator[](cr);
- if (c.reloced()) { cr = c.relocation(); return; }
-
- cr = to.alloc(c, c.learnt());
- c.relocate(cr);
-
- // Copy extra data-fields:
- // (This could be cleaned-up. Generalize Clause-constructor to be applicable
- // here instead?)
- to[cr].mark(c.mark());
- if (to[cr].learnt()) to[cr].activity() = c.activity();
- else if (to[cr].has_extra()) to[cr].calcAbstraction();
-}
-
-void Solver::setNotify(Notify* toNotify) { d_notify = toNotify; }
-bool Solver::withinBudget(Resource r) const
-{
- AlwaysAssert(d_notify);
- d_notify->safePoint(r);
-
- return !asynch_interrupt &&
- (conflict_budget < 0 || conflicts < conflict_budget) &&
- (propagation_budget < 0 ||
- propagations < propagation_budget);
-}
-
-} // namespace BVMinisat
-} // namespace cvc5
+++ /dev/null
-/****************************************************************************************[Solver.h]
-Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_Solver_h
-#define BVMinisat_Solver_h
-
-#include <vector>
-
-#include "base/check.h"
-#include "context/context.h"
-#include "proof/clause_id.h"
-#include "prop/bvminisat/core/SolverTypes.h"
-#include "prop/bvminisat/mtl/Alg.h"
-#include "prop/bvminisat/mtl/Heap.h"
-#include "prop/bvminisat/mtl/Vec.h"
-#include "prop/bvminisat/utils/Options.h"
-#include "util/resource_manager.h"
-
-namespace cvc5 {
-
-namespace BVMinisat {
-class Solver;
-}
-
-namespace BVMinisat {
-
-/** Interface for minisat callbacks */
-class Notify {
-
-public:
-
- virtual ~Notify() {}
-
- /**
- * If the notify returns false, the solver will break out of whatever it's currently doing
- * with an "unknown" answer.
- */
- virtual bool notify(Lit lit) = 0;
-
- /**
- * Notify about a new learnt clause with marked literals only.
- */
- virtual void notify(vec<Lit>& learnt) = 0;
-
- virtual void spendResource(Resource r) = 0;
- virtual void safePoint(Resource r) = 0;
-};
-
-//=================================================================================================
-// Solver -- the main class:
-class Solver {
-public:
- typedef Var TVar;
- typedef Lit TLit;
- typedef Clause TClause;
- typedef CRef TCRef;
- typedef vec<Lit> TLitVec;
-
- static CRef TCRef_Undef;
- static CRef TCRef_Lazy;
-private:
- /** To notify */
- Notify* d_notify;
-
- /** cvc5 context */
- cvc5::context::Context* c;
-
- /** True constant */
- Var varTrue;
-
- /** False constant */
- Var varFalse;
-
-public:
-
- // Constructor/Destructor:
- //
- Solver(cvc5::context::Context* c);
- virtual ~Solver();
-
- void setNotify(Notify* toNotify);
-
- // Problem specification:
- //
- Var newVar(bool polarity = true,
- bool dvar = true); // Add a new variable with parameters specifying
- // variable mode.
- Var trueVar() const { return varTrue; }
- Var falseVar() const { return varFalse; }
-
- bool addClause(const vec<Lit>& ps,
- ClauseId& id); // Add a clause to the solver.
- bool addEmptyClause(); // Add the empty clause, making the solver
- // contradictory.
- bool addClause(Lit p, ClauseId& id); // Add a unit clause to the solver.
- bool addClause(Lit p,
- Lit q,
- ClauseId& id); // Add a binary clause to the solver.
- bool addClause(Lit p,
- Lit q,
- Lit r,
- ClauseId& id); // Add a ternary clause to the solver.
- bool addClause_(
- vec<Lit>& ps,
- ClauseId& id); // Add a clause to the solver without making superflous
- // internal copy. Will change the passed vector 'ps'.
-
- // Solving:
- //
- bool simplify(); // Removes already satisfied clauses.
- lbool solve(const vec<Lit>& assumps); // Search for a model that respects a
- // given set of assumptions.
- lbool solveLimited(
- const vec<Lit>& assumps); // Search for a model that respects a given set
- // of assumptions (With resource constraints).
- lbool solve(); // Search without assumptions.
- lbool solve(Lit p); // Search for a model that respects a single assumption.
- lbool solve(Lit p,
- Lit q); // Search for a model that respects two assumptions.
- lbool solve(Lit p,
- Lit q,
- Lit r); // Search for a model that respects three assumptions.
- bool okay() const; // FALSE means solver is in a conflicting state
- lbool assertAssumption(
- Lit p,
- bool propagate); // Assert a new assumption, start BCP if propagate = true
- lbool propagateAssumptions(); // Do BCP over asserted assumptions
- void popAssumption(); // Pop an assumption
-
- void toDimacs(FILE* f,
- const vec<Lit>& assumps); // Write CNF to file in DIMACS-format.
- void toDimacs(const char* file, const vec<Lit>& assumps);
- void toDimacs(FILE* f, Clause& c, vec<Var>& map, Var& max);
-
- // Convenience versions of 'toDimacs()':
- void toDimacs(const char* file);
- void toDimacs(const char* file, Lit p);
- void toDimacs(const char* file, Lit p, Lit q);
- void toDimacs(const char* file, Lit p, Lit q, Lit r);
-
- // Variable mode:
- //
- void setPolarity(
- Var v, bool b); // Declare which polarity the decision heuristic should
- // use for a variable. Requires mode 'polarity_user'.
- void setDecisionVar(Var v,
- bool b); // Declare if a variable should be eligible for
- // selection in the decision heuristic.
-
- // Read state:
- //
- lbool value(Var x) const; // The current value of a variable.
- lbool value(Lit p) const; // The current value of a literal.
- lbool modelValue(
- Var x) const; // The value of a variable in the last model. The last call
- // to solve must have been satisfiable.
- lbool modelValue(
- Lit p) const; // The value of a literal in the last model. The last call
- // to solve must have been satisfiable.
- int nAssigns() const; // The current number of assigned literals.
- int nClauses() const; // The current number of original clauses.
- int nLearnts() const; // The current number of learnt clauses.
- int nVars() const; // The current number of variables.
- int nFreeVars() const;
-
- // Resource contraints:
- //
- void setConfBudget(int64_t x);
- void setPropBudget(int64_t x);
- void budgetOff();
- void interrupt(); // Trigger a (potentially asynchronous) interruption of the
- // solver.
- void clearInterrupt(); // Clear interrupt indicator flag.
-
- // Memory managment:
- //
- virtual void garbageCollect();
- void checkGarbage(double gf);
- void checkGarbage();
-
- // Extra results: (read-only member variable)
- //
- vec<lbool> model; // If problem is satisfiable, this vector contains the model
- // (if any).
- vec<Lit> conflict; // If problem is unsatisfiable (possibly under
- // assumptions), this vector represent the final conflict
- // clause expressed in the assumptions.
-
- // Mode of operation:
- //
- int verbosity;
- double var_decay;
- double clause_decay;
- double random_var_freq;
- double random_seed;
- bool luby_restart;
- int ccmin_mode; // Controls conflict clause minimization (0=none, 1=basic,
- // 2=deep).
- int phase_saving; // Controls the level of phase saving (0=none, 1=limited,
- // 2=full).
- bool rnd_pol; // Use random polarities for branching heuristics.
- bool
- rnd_init_act; // Initialize variable activities with a small random value.
- double garbage_frac; // The fraction of wasted memory allowed before a garbage
- // collection is triggered.
-
- int restart_first; // The initial restart limit. (default 100)
- double restart_inc; // The factor with which the restart limit is multiplied
- // in each restart. (default 1.5)
- double
- learntsize_factor; // The intitial limit for learnt clauses is a factor of
- // the original clauses. (default 1 / 3)
- double learntsize_inc; // The limit for learnt clauses is multiplied with this
- // factor each restart. (default 1.1)
-
- int learntsize_adjust_start_confl;
- double learntsize_adjust_inc;
-
- // Statistics: (read-only member variable)
- //
- int64_t solves, starts, decisions, rnd_decisions, propagations, conflicts;
- int64_t dec_vars, clauses_literals, learnts_literals, max_literals,
- tot_literals;
-
- // Bitvector Propagations
- //
-
- void addMarkerLiteral(Var var);
-
- bool need_to_propagate; // true if we added new clauses, set to true in
- // propagation
- bool only_bcp; // solving mode in which only boolean constraint propagation is
- // done
- void setOnlyBCP(bool val) { only_bcp = val; }
- void explain(Lit l, std::vector<Lit>& explanation);
-
-protected:
- // has a clause been added
- bool clause_added;
-
- // Helper structures:
- //
- struct VarData
- {
- CRef reason;
- int level; };
- static inline VarData mkVarData(CRef cr, int l){ VarData d = {cr, l}; return d; }
-
- struct Watcher {
- CRef cref;
- Lit blocker;
- Watcher(CRef cr, Lit p) : cref(cr), blocker(p) {}
- bool operator==(const Watcher& w) const { return cref == w.cref; }
- bool operator!=(const Watcher& w) const { return cref != w.cref; }
- };
-
- struct WatcherDeleted
- {
- const ClauseAllocator& ca;
- WatcherDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
- bool operator()(const Watcher& w) const { return ca[w.cref].mark() == 1; }
- };
-
- struct VarOrderLt {
- const vec<double>& activity;
- bool operator () (Var x, Var y) const { return activity[x] > activity[y]; }
- VarOrderLt(const vec<double>& act) : activity(act) { }
- };
-
- // Solver state:
- //
- bool ok; // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used!
- vec<CRef> clauses; // List of problem clauses.
- vec<CRef> learnts; // List of learnt clauses.
- double cla_inc; // Amount to bump next clause with.
- vec<double> activity; // A heuristic measurement of the activity of a variable.
- double var_inc; // Amount to bump next variable with.
- OccLists<Lit, vec<Watcher>, WatcherDeleted>
- watches; // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
- vec<lbool> assigns; // The current assignments.
- vec<char> polarity; // The preferred polarity of each variable.
- vec<char> marker; // Is the variable a marker literal
- vec<char> decision; // Declares if a variable is eligible for selection in the decision heuristic.
- vec<Lit> trail; // Assignment stack; stores all assigments made in the order they were made.
- vec<int> trail_lim; // Separator indices for different decision levels in 'trail'.
- vec<VarData> vardata; // Stores reason and level for each variable.
- int qhead; // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat).
- int simpDB_assigns; // Number of top-level assignments since last execution of 'simplify()'.
- int64_t simpDB_props; // Remaining number of propagations that must be made before next execution of 'simplify()'.
- vec<Lit> assumptions; // Current set of assumptions provided to solve by the user.
- Heap<VarOrderLt> order_heap; // A priority queue of variables ordered with respect to the variable activity.
- double progress_estimate;// Set by 'search()'.
- bool remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'.
-
- ClauseAllocator ca;
-
- // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which it is
- // used, exept 'seen' wich is used in several places.
- //
- vec<char> seen;
- vec<Lit> analyze_stack;
- vec<Lit> analyze_toclear;
- vec<Lit> add_tmp;
-
- double max_learnts;
- double learntsize_adjust_confl;
- int learntsize_adjust_cnt;
-
- // Resource contraints:
- //
- int64_t conflict_budget; // -1 means no budget.
- int64_t propagation_budget; // -1 means no budget.
- bool asynch_interrupt;
-
- // Main internal methods:
- //
- void insertVarOrder (Var x); // Insert a variable in the decision order priority queue.
- Lit pickBranchLit (); // Return the next decision variable.
- void newDecisionLevel (); // Begins a new decision level.
- void uncheckedEnqueue (Lit p, CRef from = CRef_Undef); // Enqueue a literal. Assumes value of literal is undefined.
- bool enqueue (Lit p, CRef from = CRef_Undef); // Test if fact 'p' contradicts current state, enqueue otherwise.
- CRef propagate (); // Perform unit propagation. Returns possibly conflicting clause.
- void cancelUntil (int level); // Backtrack until a certain level.
-
- enum UIP {
- UIP_FIRST,
- UIP_LAST
- };
-
- void analyze (CRef confl, vec<Lit>& out_learnt, int& out_btlevel, UIP uip = UIP_FIRST); // (bt = backtrack)
- void analyzeFinal (Lit p, vec<Lit>& out_conflict); // COULD THIS BE IMPLEMENTED BY THE ORDINARIY "analyze" BY SOME REASONABLE GENERALIZATION?
- void analyzeFinal2(Lit p, CRef confl_clause, vec<Lit>& out_conflict);
- bool litRedundant (Lit p, uint32_t abstract_levels); // (helper method for 'analyze()')
- lbool search (int nof_conflicts, UIP uip = UIP_FIRST); // Search for a given number of conflicts.
- lbool solve_ (); // Main solve method (assumptions given in 'assumptions').
- void reduceDB (); // Reduce the set of learnt clauses.
- void removeSatisfied (vec<CRef>& cs); // Shrink 'cs' to contain only non-satisfied clauses.
- void rebuildOrderHeap ();
-
- // Maintaining Variable/Clause activity:
- //
- void varDecayActivity (); // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead.
- void varBumpActivity (Var v, double inc); // Increase a variable with the current 'bump' value.
- void varBumpActivity (Var v); // Increase a variable with the current 'bump' value.
- void claDecayActivity (); // Decay all clauses with the specified factor. Implemented by increasing the 'bump' value instead.
- void claBumpActivity (Clause& c); // Increase a clause with the current 'bump' value.
-
- // Operations on clauses:
- //
- void attachClause (CRef cr); // Attach a clause to watcher lists.
- void detachClause (CRef cr, bool strict = false); // Detach a clause to watcher lists.
- void removeClause (CRef cr); // Detach and free a clause.
- bool locked (const Clause& c) const; // Returns TRUE if a clause is a reason for some implication in the current state.
- bool satisfied (const Clause& c) const; // Returns TRUE if a clause is satisfied in the current state.
-
- void relocAll (ClauseAllocator& to);
-
- // Misc:
- //
- int decisionLevel () const; // Gives the current decisionlevel.
- uint32_t abstractLevel (Var x) const; // Used to represent an abstraction of sets of decision levels.
- CRef reason (Var x) const;
- int level (Var x) const;
- double progressEstimate () const; // DELETE THIS ?? IT'S NOT VERY USEFUL ...
- bool withinBudget(Resource r) const;
-
- // Static helpers:
- //
-
- // Returns a random float 0 <= x < 1. Seed must never be 0.
- static inline double drand(double& seed) {
- seed *= 1389796;
- int q = (int)(seed / 2147483647);
- seed -= (double)q * 2147483647;
- return seed / 2147483647; }
-
- // Returns a random integer 0 <= x < size. Seed must never be 0.
- static inline int irand(double& seed, int size) {
- return (int)(drand(seed) * size); }
-
- // Less than for literals in an added clause when proofs are on.
- struct assign_lt {
- Solver& d_solver;
- assign_lt(Solver& solver) : d_solver(solver) {}
- bool operator () (Lit x, Lit y) {
- lbool x_value = d_solver.value(x);
- lbool y_value = d_solver.value(y);
- // Two unassigned literals are sorted arbitrarily
- if (x_value == l_Undef && y_value == l_Undef) {
- return x < y;
- }
- // Unassigned literals are put to front
- if (x_value == l_Undef) return true;
- if (y_value == l_Undef) return false;
- // Literals of the same value are sorted by decreasing levels
- if (x_value == y_value) {
- return d_solver.level(var(x)) > d_solver.level(var(y));
- } else {
- // True literals go up front
- if (x_value == l_True) {
- return true;
- } else {
- return false;
- }
- }
- }
- };
-
-};
-
-
-//=================================================================================================
-// Implementation of inline methods:
-
-inline CRef Solver::reason(Var x) const
-{
- Assert(x < vardata.size());
- return vardata[x].reason;
-}
-inline int Solver::level(Var x) const
-{
- Assert(x < vardata.size());
- return vardata[x].level;
-}
-
-inline void Solver::insertVarOrder(Var x) {
- if (!order_heap.inHeap(x) && decision[x]) order_heap.insert(x); }
-
-inline void Solver::varDecayActivity() { var_inc *= (1 / var_decay); }
-inline void Solver::varBumpActivity(Var v) { varBumpActivity(v, var_inc); }
-inline void Solver::varBumpActivity(Var v, double inc) {
- if ( (activity[v] += inc) > 1e100 ) {
- // Rescale:
- for (int i = 0; i < nVars(); i++)
- activity[i] *= 1e-100;
- var_inc *= 1e-100; }
-
- // Update order_heap with respect to new activity:
- if (order_heap.inHeap(v))
- order_heap.decrease(v); }
-
-inline void Solver::claDecayActivity() { cla_inc *= (1 / clause_decay); }
-inline void Solver::claBumpActivity(Clause& clause)
-{
- if ((clause.activity() += cla_inc) > 1e20)
- {
- // Rescale:
- for (int i = 0; i < learnts.size(); i++) ca[learnts[i]].activity() *= 1e-20;
- cla_inc *= 1e-20;
- }
-}
-
-inline void Solver::checkGarbage(void){ return checkGarbage(garbage_frac); }
-inline void Solver::checkGarbage(double gf){
- if (ca.wasted() > ca.size() * gf)
- garbageCollect(); }
-
-// NOTE: enqueue does not set the ok flag! (only public methods do)
-inline bool Solver::enqueue (Lit p, CRef from) { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, from), true); }
-inline bool Solver::addClause (const vec<Lit>& ps, ClauseId& id) { ps.copyTo(add_tmp); return addClause_(add_tmp, id); }
-inline bool Solver::addEmptyClause () { add_tmp.clear(); ClauseId tmp; return addClause_(add_tmp, tmp); }
-inline bool Solver::addClause (Lit p, ClauseId& id) { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp, id); }
-inline bool Solver::addClause (Lit p, Lit q, ClauseId& id) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp, id); }
-inline bool Solver::addClause (Lit p, Lit q, Lit r, ClauseId& id) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp, id); }
-inline bool Solver::locked(const Clause& clause) const
-{
- return value(clause[0]) == l_True && reason(var(clause[0])) != CRef_Undef
- && ca.lea(reason(var(clause[0]))) == &clause;
-}
-inline void Solver::newDecisionLevel() { trail_lim.push(trail.size()); }
-
-inline int Solver::decisionLevel () const { return trail_lim.size(); }
-inline uint32_t Solver::abstractLevel (Var x) const { return 1 << (level(x) & 31); }
-inline lbool Solver::value (Var x) const { return assigns[x]; }
-inline lbool Solver::value (Lit p) const { return assigns[var(p)] ^ sign(p); }
-inline lbool Solver::modelValue (Var x) const { return model[x]; }
-inline lbool Solver::modelValue (Lit p) const { return model[var(p)] ^ sign(p); }
-inline int Solver::nAssigns () const { return trail.size(); }
-inline int Solver::nClauses () const { return clauses.size(); }
-inline int Solver::nLearnts () const { return learnts.size(); }
-inline int Solver::nVars () const { return vardata.size(); }
-inline int Solver::nFreeVars () const { return (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]); }
-inline void Solver::setPolarity (Var v, bool b) { polarity[v] = b; }
-inline void Solver::setDecisionVar(Var v, bool b)
-{
- if (b && !decision[v])
- dec_vars++;
- else if (!b && decision[v])
- dec_vars--;
-
- decision[v] = b;
- insertVarOrder(v);
-}
-inline void Solver::setConfBudget(int64_t x){ conflict_budget = conflicts + x; }
-inline void Solver::setPropBudget(int64_t x){ propagation_budget = propagations + x; }
-inline void Solver::interrupt(){ asynch_interrupt = true; }
-inline void Solver::clearInterrupt(){ asynch_interrupt = false; }
-inline void Solver::budgetOff(){ conflict_budget = propagation_budget = -1; }
-
-inline lbool Solver::solve () { budgetOff(); return solve_(); }
-inline lbool Solver::solve (Lit p) { budgetOff(); assumptions.push(p); return solve_(); }
-inline lbool Solver::solve (Lit p, Lit q) { budgetOff(); assumptions.push(p); assumptions.push(q); return solve_(); }
-inline lbool Solver::solve (Lit p, Lit q, Lit r) { budgetOff(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_(); }
-inline lbool Solver::solve (const vec<Lit>& assumps){ budgetOff(); assumps.copyTo(assumptions); return solve_(); }
-inline lbool Solver::solveLimited (const vec<Lit>& assumps){ assumps.copyTo(assumptions); return solve_(); }
-inline bool Solver::okay () const { return ok; }
-
-inline void Solver::toDimacs (const char* file){ vec<Lit> as; toDimacs(file, as); }
-inline void Solver::toDimacs (const char* file, Lit p){ vec<Lit> as; as.push(p); toDimacs(file, as); }
-inline void Solver::toDimacs (const char* file, Lit p, Lit q){ vec<Lit> as; as.push(p); as.push(q); toDimacs(file, as); }
-inline void Solver::toDimacs (const char* file, Lit p, Lit q, Lit r){ vec<Lit> as; as.push(p); as.push(q); as.push(r); toDimacs(file, as); }
-
-
-//=================================================================================================
-// Debug etc:
-
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/***********************************************************************************[SolverTypes.h]
-Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_SolverTypes_h
-#define BVMinisat_SolverTypes_h
-
-#include "base/check.h"
-#include "prop/bvminisat/mtl/Alg.h"
-#include "prop/bvminisat/mtl/Alloc.h"
-#include "prop/bvminisat/mtl/IntTypes.h"
-#include "prop/bvminisat/mtl/Map.h"
-#include "prop/bvminisat/mtl/Vec.h"
-
-namespace cvc5 {
-namespace BVMinisat {
-class Solver;
-}
-template <class Solver>
-class TSatProof;
-} // namespace cvc5
-
-namespace cvc5 {
-
-namespace BVMinisat {
-
-//=================================================================================================
-// Variables, literals, lifted booleans, clauses:
-
-
-// NOTE! Variables are just integers. No abstraction here. They should be chosen from 0..N,
-// so that they can be used as array indices.
-
-typedef int Var;
-#define var_Undef (-1)
-
-
-struct Lit {
- int x;
-
- // Use this as a constructor:
- friend Lit mkLit(Var var, bool sign);
-
- bool operator == (Lit p) const { return x == p.x; }
- bool operator != (Lit p) const { return x != p.x; }
- bool operator < (Lit p) const { return x < p.x; } // '<' makes p, ~p adjacent in the ordering.
-};
-
-inline Lit mkLit (Var var, bool sign = false) { Lit p; p.x = var + var + (int)sign; return p; }
-inline Lit operator ~(Lit p) { Lit q; q.x = p.x ^ 1; return q; }
-inline Lit operator ^(Lit p, bool b) { Lit q; q.x = p.x ^ (unsigned int)b; return q; }
-inline bool sign (Lit p) { return p.x & 1; }
-inline int var (Lit p) { return p.x >> 1; }
-
-// Mapping Literals to and from compact integers suitable for array indexing:
-inline int toInt (Var v) { return v; }
-inline int toInt (Lit p) { return p.x; }
-inline Lit toLit (int i) { Lit p; p.x = i; return p; }
-
-struct LitHashFunction {
- size_t operator () (const Lit& l) const {
- return toInt(l);
- }
-};
-
-//const Lit lit_Undef = mkLit(var_Undef, false); // }- Useful special constants.
-//const Lit lit_Error = mkLit(var_Undef, true ); // }
-
-const Lit lit_Undef = { -2 }; // }- Useful special constants.
-const Lit lit_Error = { -1 }; // }
-
-//=================================================================================================
-// Lifted booleans:
-//
-// NOTE: this implementation is optimized for the case when comparisons between
-// values are mostly
-// between one variable and one constant. Some care had to be taken to
-// make sure that gcc does enough constant propagation to produce sensible
-// code, and this appears to be somewhat fragile unfortunately.
-
-#ifndef l_True
-#define l_True (lbool((uint8_t)0)) // gcc does not do constant propagation if these are real constants.
-#endif
-
-#ifndef l_False
-#define l_False (lbool((uint8_t)1))
-#endif
-
-#ifndef l_Undef
-#define l_Undef (lbool((uint8_t)2))
-#endif
-
-class lbool {
- uint8_t value;
-
-public:
- explicit lbool(uint8_t v) : value(v) { }
-
- lbool() : value(0) { }
- explicit lbool(bool x) : value(!x) { }
-
- bool operator == (lbool b) const { return ((b.value&2) & (value&2)) | (!(b.value&2)&(value == b.value)); }
- bool operator != (lbool b) const { return !(*this == b); }
- lbool operator ^ (bool b) const { return lbool((uint8_t)(value^(uint8_t)b)); }
-
- lbool operator&&(lbool b) const
- {
- uint8_t sel = (this->value << 1) | (b.value << 3);
- uint8_t v = (0xF7F755F4 >> sel) & 3;
- return lbool(v);
- }
-
- lbool operator || (lbool b) const {
- uint8_t sel = (this->value << 1) | (b.value << 3);
- uint8_t v = (0xFCFCF400 >> sel) & 3;
- return lbool(v); }
-
- friend int toInt (lbool l);
- friend lbool toLbool(int v);
-};
-inline int toInt (lbool l) { return l.value; }
-inline lbool toLbool(int v) { return lbool((uint8_t)v); }
-
-//=================================================================================================
-// Clause -- a simple class for representing a clause:
-
-class Clause;
-typedef RegionAllocator<uint32_t>::Ref CRef;
-
-class Clause {
- struct {
- unsigned mark : 2;
- unsigned learnt : 1;
- unsigned has_extra : 1;
- unsigned reloced : 1;
- unsigned size : 27; } header;
- union { Lit lit; float act; uint32_t abs; CRef rel; } data[0];
-
- friend class ClauseAllocator;
-
- // NOTE: This constructor cannot be used directly (doesn't allocate enough memory).
- template<class V>
- Clause(const V& ps, bool use_extra, bool learnt) {
- header.mark = 0;
- header.learnt = learnt;
- header.has_extra = use_extra;
- header.reloced = 0;
- header.size = ps.size();
-
- for (int i = 0; i < ps.size(); i++) data[i].lit = ps[i];
-
- if (header.has_extra){
- if (header.learnt)
- data[header.size].act = 0;
- else
- calcAbstraction();
- }
- }
-
-public:
- void calcAbstraction() {
- Assert(header.has_extra);
- uint32_t abstraction = 0;
- for (int i = 0; i < size(); i++)
- abstraction |= 1 << (var(data[i].lit) & 31);
- data[header.size].abs = abstraction;
- }
-
- int size () const { return header.size; }
- void shrink(int i)
- {
- Assert(i <= size());
- if (header.has_extra) data[header.size - i] = data[header.size];
- header.size -= i;
- }
- void pop () { shrink(1); }
- bool learnt () const { return header.learnt; }
- bool has_extra () const { return header.has_extra; }
- uint32_t mark () const { return header.mark; }
- void mark (uint32_t m) { header.mark = m; }
- const Lit& last () const { return data[header.size-1].lit; }
-
- bool reloced () const { return header.reloced; }
- CRef relocation () const { return data[0].rel; }
- void relocate (CRef c) { header.reloced = 1; data[0].rel = c; }
-
- // NOTE: somewhat unsafe to change the clause in-place! Must manually call 'calcAbstraction' afterwards for
- // subsumption operations to behave correctly.
- Lit& operator [] (int i) { return data[i].lit; }
- Lit operator [] (int i) const { return data[i].lit; }
- operator const Lit* (void) const { return (Lit*)data; }
-
- float& activity()
- {
- Assert(header.has_extra);
- return data[header.size].act;
- }
- uint32_t abstraction() const
- {
- Assert(header.has_extra);
- return data[header.size].abs;
- }
-
- Lit subsumes (const Clause& other) const;
- void strengthen (Lit p);
-};
-
-
-//=================================================================================================
-// ClauseAllocator -- a simple class for allocating memory for clauses:
-
-
-const CRef CRef_Undef = RegionAllocator<uint32_t>::Ref_Undef;
-const CRef CRef_Lazy = RegionAllocator<uint32_t>::Ref_Undef - 1;
-
-class ClauseAllocator : public RegionAllocator<uint32_t>
-{
- static int clauseWord32Size(int size, bool has_extra){
- return (sizeof(Clause) + (sizeof(Lit) * (size + (int)has_extra))) / sizeof(uint32_t); }
- public:
- bool extra_clause_field;
-
- ClauseAllocator(uint32_t start_cap) : RegionAllocator<uint32_t>(start_cap), extra_clause_field(false){}
- ClauseAllocator() : extra_clause_field(false){}
-
- void moveTo(ClauseAllocator& to){
- to.extra_clause_field = extra_clause_field;
- RegionAllocator<uint32_t>::moveTo(to); }
-
- template<class Lits>
- CRef alloc(const Lits& ps, bool learnt = false)
- {
- Assert(sizeof(Lit) == sizeof(uint32_t));
- Assert(sizeof(float) == sizeof(uint32_t));
- bool use_extra = learnt | extra_clause_field;
-
- CRef cid = RegionAllocator<uint32_t>::alloc(
- clauseWord32Size(ps.size(), use_extra));
- new (lea(cid)) Clause(ps, use_extra, learnt);
-
- return cid;
- }
-
- // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
- Clause& operator[](Ref r) { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
- const Clause& operator[](Ref r) const { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
- Clause* lea (Ref r) { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
- const Clause* lea (Ref r) const { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
- Ref ael (const Clause* t){ return RegionAllocator<uint32_t>::ael((uint32_t*)t); }
-
- void free(CRef cid)
- {
- Clause& c = operator[](cid);
- RegionAllocator<uint32_t>::free(clauseWord32Size(c.size(), c.has_extra()));
- }
-
- void reloc(CRef& cr, ClauseAllocator& to);
-};
-
-
-//=================================================================================================
-// OccLists -- a class for maintaining occurence lists with lazy deletion:
-
-template<class Idx, class Vec, class Deleted>
-class OccLists
-{
- vec<Vec> occs;
- vec<char> dirty;
- vec<Idx> dirties;
- Deleted deleted;
-
- public:
- OccLists(const Deleted& d) : deleted(d) {}
-
- void init (const Idx& idx){ occs.growTo(toInt(idx)+1); dirty.growTo(toInt(idx)+1, 0); }
- // Vec& operator[](const Idx& idx){ return occs[toInt(idx)]; }
- Vec& operator[](const Idx& idx){ return occs[toInt(idx)]; }
- Vec& lookup (const Idx& idx){ if (dirty[toInt(idx)]) clean(idx); return occs[toInt(idx)]; }
-
- void cleanAll ();
- void clean (const Idx& idx);
- void smudge (const Idx& idx){
- if (dirty[toInt(idx)] == 0){
- dirty[toInt(idx)] = 1;
- dirties.push(idx);
- }
- }
-
- void clear(bool free = true){
- occs .clear(free);
- dirty .clear(free);
- dirties.clear(free);
- }
-};
-
-
-template<class Idx, class Vec, class Deleted>
-void OccLists<Idx,Vec,Deleted>::cleanAll()
-{
- for (int i = 0; i < dirties.size(); i++)
- // Dirties may contain duplicates so check here if a variable is already cleaned:
- if (dirty[toInt(dirties[i])])
- clean(dirties[i]);
- dirties.clear();
-}
-
-
-template<class Idx, class Vec, class Deleted>
-void OccLists<Idx,Vec,Deleted>::clean(const Idx& idx)
-{
- Vec& vec = occs[toInt(idx)];
- int i, j;
- for (i = j = 0; i < vec.size(); i++)
- if (!deleted(vec[i]))
- vec[j++] = vec[i];
- vec.shrink(i - j);
- dirty[toInt(idx)] = 0;
-}
-
-
-//=================================================================================================
-// CMap -- a class for mapping clauses to values:
-
-
-template<class T>
-class CMap
-{
- struct CRefHash {
- uint32_t operator()(CRef cr) const { return (uint32_t)cr; } };
-
- typedef Map<CRef, T, CRefHash> HashTable;
- HashTable map;
-
- public:
- // Size-operations:
- void clear () { map.clear(); }
- int size () const { return map.elems(); }
-
- // Insert/Remove/Test mapping:
- void insert (CRef cr, const T& t){ map.insert(cr, t); }
- void growTo (CRef cr, const T& t){ map.insert(cr, t); } // NOTE: for compatibility
- void remove (CRef cr) { map.remove(cr); }
- bool has (CRef cr, T& t) { return map.peek(cr, t); }
-
- // Vector interface (the clause 'c' must already exist):
- const T& operator [] (CRef cr) const { return map[cr]; }
- T& operator [] (CRef cr) { return map[cr]; }
-
- // Iteration (not transparent at all at the moment):
- int bucket_count() const { return map.bucket_count(); }
- const vec<typename HashTable::Pair>& bucket(int i) const { return map.bucket(i); }
-
- // Move contents to other map:
- void moveTo(CMap& other){ map.moveTo(other.map); }
-
- // TMP debug:
- void debug(){
- printf(" --- size = %d, bucket_count = %d\n", size(), map.bucket_count()); }
-};
-
-/*_________________________________________________________________________________________________
-|
-| subsumes : (other : const Clause&) -> Lit
-|
-| Description:
-| Checks if clause subsumes 'other', and at the same time, if it can be
-used to simplify 'other' | by subsumption resolution.
-|
-| Result:
-| lit_Error - No subsumption or simplification
-| lit_Undef - Clause subsumes 'other'
-| p - The literal p can be deleted from 'other'
-|________________________________________________________________________________________________@*/
-inline Lit Clause::subsumes(const Clause& other) const
-{
- //if (other.size() < size() || (extra.abst & ~other.extra.abst) != 0)
- //if (other.size() < size() || (!learnt() && !other.learnt() && (extra.abst & ~other.extra.abst) != 0))
- Assert(!header.learnt);
- Assert(!other.header.learnt);
- Assert(header.has_extra);
- Assert(other.header.has_extra);
- if (other.header.size < header.size || (data[header.size].abs & ~other.data[other.header.size].abs) != 0)
- return lit_Error;
-
- Lit ret = lit_Undef;
- const Lit* c = (const Lit*)(*this);
- const Lit* d = (const Lit*)other;
-
- for (unsigned i = 0; i < header.size; i++) {
- // search for c[i] or ~c[i]
- for (unsigned j = 0; j < other.header.size; j++)
- if (c[i] == d[j])
- goto ok;
- else if (ret == lit_Undef && c[i] == ~d[j]){
- ret = c[i];
- goto ok;
- }
-
- // did not find it
- return lit_Error;
- ok:;
- }
-
- return ret;
-}
-
-inline void Clause::strengthen(Lit p)
-{
- remove(*this, p);
- calcAbstraction();
-}
-
-
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-Release Notes for MiniSat 2.2.0
-===============================
-
-Changes since version 2.0:
-
- * Started using a more standard release numbering.
-
- * Includes some now well-known heuristics: phase-saving and luby
- restarts. The old heuristics are still present and can be activated
- if needed.
-
- * Detection/Handling of out-of-memory and vector capacity
- overflow. This is fairly new and relatively untested.
-
- * Simple resource controls: CPU-time, memory, number of
- conflicts/decisions.
-
- * CPU-time limiting is implemented by a more general, but simple,
- asynchronous interruption feature. This means that the solving
- procedure can be interrupted from another thread or in a signal
- handler.
-
- * Improved portability with respect to building on Solaris and with
- Visual Studio. This is not regularly tested and chances are that
- this have been broken since, but should be fairly easy to fix if
- so.
-
- * Changed C++ file-extention to the less problematic ".cc".
-
- * Source code is now namespace-protected
-
- * Introducing a new Clause Memory Allocator that brings reduced
- memory consumption on 64-bit architechtures and improved
- performance (to some extent). The allocator uses a region-based
- approach were all references to clauses are represented as a 32-bit
- index into a global memory region that contains all clauses. To
- free up and compact memory it uses a simple copying garbage
- collector.
-
- * Improved unit-propagation by Blocking Literals. For each entry in
- the watcher lists, pair the pointer to a clause with some
- (arbitrary) literal from the clause. The idea is that if the
- literal is currently true (i.e. the clause is satisfied) the
- watchers of the clause does not need to be altered. This can thus
- be detected without touching the clause's memory at all. As often
- as can be done cheaply, the blocking literal for entries to the
- watcher list of a literal 'p' is set to the other literal watched
- in the corresponding clause.
-
- * Basic command-line/option handling system. Makes it easy to specify
- options in the class that they affect, and whenever that class is
- used in an executable, parsing of options and help messages are
- brought in automatically.
-
- * General clean-up and various minor bug-fixes.
-
- * Changed implementation of variable-elimination/model-extension:
-
- - The interface is changed so that arbitrary remembering is no longer
- possible. If you need to mention some variable again in the future,
- this variable has to be frozen.
-
- - When eliminating a variable, only clauses that contain the variable
- with one sign is necessary to store. Thereby making the other sign
- a "default" value when extending models.
-
- - The memory consumption for eliminated clauses is further improved
- by storing all eliminated clauses in a single contiguous vector.
-
- * Some common utility code (I/O, Parsing, CPU-time, etc) is ripped
- out and placed in a separate "utils" directory.
-
- * The DIMACS parse is refactored so that it can be reused in other
- applications (not very elegant, but at least possible).
-
- * Some simple improvements to scalability of preprocessing, using
- more lazy clause removal from data-structures and a couple of
- ad-hoc limits (the longest clause that can be produced in variable
- elimination, and the longest clause used in backward subsumption).
+++ /dev/null
-/*******************************************************************************************[Alg.h]
-Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_Alg_h
-#define BVMinisat_Alg_h
-
-#include "base/check.h"
-#include "prop/bvminisat/mtl/Vec.h"
-
-namespace cvc5 {
-namespace BVMinisat {
-
-//=================================================================================================
-// Useful functions on vector-like types:
-
-//=================================================================================================
-// Removing and searching for elements:
-//
-
-template<class V, class T>
-static inline void remove(V& ts, const T& t)
-{
- int j = 0;
- for (; j < ts.size() && ts[j] != t; j++);
- Assert(j < ts.size());
- for (; j < ts.size()-1; j++) ts[j] = ts[j+1];
- ts.pop();
-}
-
-
-template<class V, class T>
-static inline bool find(V& ts, const T& t)
-{
- int j = 0;
- for (; j < ts.size() && ts[j] != t; j++);
- return j < ts.size();
-}
-
-
-//=================================================================================================
-// Copying vectors with support for nested vector types:
-//
-
-// Base case:
-template<class T>
-static inline void copy(const T& from, T& to)
-{
- to = from;
-}
-
-// Recursive case:
-template<class T>
-static inline void copy(const vec<T>& from, vec<T>& to, bool append = false)
-{
- if (!append)
- to.clear();
- for (int i = 0; i < from.size(); i++){
- to.push();
- copy(from[i], to.last());
- }
-}
-
-template<class T>
-static inline void append(const vec<T>& from, vec<T>& to){ copy(from, to, true); }
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/*****************************************************************************************[Alloc.h]
-Copyright (c) 2008-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-
-#ifndef BVMinisat_Alloc_h
-#define BVMinisat_Alloc_h
-
-#include "base/check.h"
-#include "prop/bvminisat/mtl/Vec.h"
-#include "prop/bvminisat/mtl/XAlloc.h"
-
-namespace cvc5 {
-namespace BVMinisat {
-
-//=================================================================================================
-// Simple Region-based memory allocator:
-
-template<class T>
-class RegionAllocator
-{
- T* memory;
- uint32_t sz;
- uint32_t cap;
- uint32_t wasted_;
-
- void capacity(uint32_t min_cap);
-
- public:
- // TODO: make this a class for better type-checking?
- typedef uint32_t Ref;
- enum { Ref_Undef = UINT32_MAX };
- enum { Unit_Size = sizeof(uint32_t) };
-
- explicit RegionAllocator(uint32_t start_cap = 1024*1024) : memory(NULL), sz(0), cap(0), wasted_(0){ capacity(start_cap); }
- ~RegionAllocator()
- {
- if (memory != NULL)
- ::free(memory);
- }
-
-
- uint32_t size () const { return sz; }
- uint32_t wasted () const { return wasted_; }
-
- Ref alloc (int size);
- void free (int size) { wasted_ += size; }
-
- // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
- T& operator[](Ref r)
- {
- Assert(r >= 0 && r < sz);
- return memory[r];
- }
- const T& operator[](Ref r) const
- {
- Assert(r >= 0 && r < sz);
- return memory[r];
- }
-
- T* lea(Ref r)
- {
- Assert(r >= 0 && r < sz);
- return &memory[r];
- }
- const T* lea(Ref r) const
- {
- Assert(r >= 0 && r < sz);
- return &memory[r];
- }
- Ref ael(const T* t)
- {
- Assert((void*)t >= (void*)&memory[0]
- && (void*)t < (void*)&memory[sz - 1]);
- return (Ref)(t - &memory[0]);
- }
-
- void moveTo(RegionAllocator& to) {
- if (to.memory != NULL) ::free(to.memory);
- to.memory = memory;
- to.sz = sz;
- to.cap = cap;
- to.wasted_ = wasted_;
-
- memory = NULL;
- sz = cap = wasted_ = 0;
- }
-
-
-};
-
-template<class T>
-void RegionAllocator<T>::capacity(uint32_t min_cap)
-{
- if (cap >= min_cap) return;
-
- uint32_t prev_cap = cap;
- while (cap < min_cap){
- // NOTE: Multiply by a factor (13/8) without causing overflow, then add 2 and make the
- // result even by clearing the least significant bit. The resulting sequence of capacities
- // is carefully chosen to hit a maximum capacity that is close to the '2^32-1' limit when
- // using 'uint32_t' as indices so that as much as possible of this space can be used.
- uint32_t delta = ((cap >> 1) + (cap >> 3) + 2) & ~1;
- cap += delta;
-
- if (cap <= prev_cap)
- throw OutOfMemoryException();
- }
- // printf(" .. (%p) cap = %u\n", this, cap);
-
- Assert(cap > 0);
- memory = (T*)xrealloc(memory, sizeof(T)*cap);
-}
-
-
-template<class T>
-typename RegionAllocator<T>::Ref
-RegionAllocator<T>::alloc(int size)
-{
- // printf("ALLOC called (this = %p, size = %d)\n", this, size); fflush(stdout);
- Assert(size > 0);
- capacity(sz + size);
-
- uint32_t prev_sz = sz;
- sz += size;
-
- // Handle overflow:
- if (sz < prev_sz)
- throw OutOfMemoryException();
-
- return prev_sz;
-}
-
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/******************************************************************************************[Heap.h]
-Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_Heap_h
-#define BVMinisat_Heap_h
-
-#include "base/check.h"
-#include "prop/bvminisat/mtl/Vec.h"
-
-namespace cvc5 {
-namespace BVMinisat {
-
-//=================================================================================================
-// A heap implementation with support for decrease/increase key.
-
-
-template<class Comp>
-class Heap {
- Comp lt; // The heap is a minimum-heap with respect to this comparator
- vec<int> heap; // Heap of integers
- vec<int> indices; // Each integers position (index) in the Heap
-
- // Index "traversal" functions
- static inline int left (int i) { return i*2+1; }
- static inline int right (int i) { return (i+1)*2; }
- static inline int parent(int i) { return (i-1) >> 1; }
-
-
- void percolateUp(int i)
- {
- int x = heap[i];
- int p = parent(i);
-
- while (i != 0 && lt(x, heap[p])){
- heap[i] = heap[p];
- indices[heap[p]] = i;
- i = p;
- p = parent(p);
- }
- heap [i] = x;
- indices[x] = i;
- }
-
-
- void percolateDown(int i)
- {
- int x = heap[i];
- while (left(i) < heap.size()){
- int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i);
- if (!lt(heap[child], x)) break;
- heap[i] = heap[child];
- indices[heap[i]] = i;
- i = child;
- }
- heap [i] = x;
- indices[x] = i;
- }
-
-
- public:
- Heap(const Comp& c) : lt(c) { }
-
- int size () const { return heap.size(); }
- bool empty () const { return heap.size() == 0; }
- bool inHeap (int n) const { return n < indices.size() && indices[n] >= 0; }
- int operator[](int index) const
- {
- Assert(index < heap.size());
- return heap[index];
- }
-
- void decrease(int n)
- {
- Assert(inHeap(n));
- percolateUp(indices[n]);
- }
- void increase(int n)
- {
- Assert(inHeap(n));
- percolateDown(indices[n]);
- }
-
- // Safe variant of insert/decrease/increase:
- void update(int n)
- {
- if (!inHeap(n))
- insert(n);
- else {
- percolateUp(indices[n]);
- percolateDown(indices[n]); }
- }
-
-
- void insert(int n)
- {
- indices.growTo(n+1, -1);
- Assert(!inHeap(n));
-
- indices[n] = heap.size();
- heap.push(n);
- percolateUp(indices[n]);
- }
-
-
- int removeMin()
- {
- int x = heap[0];
- heap[0] = heap.last();
- indices[heap[0]] = 0;
- indices[x] = -1;
- heap.pop();
- if (heap.size() > 1) percolateDown(0);
- return x;
- }
-
-
- // Rebuild the heap from scratch, using the elements in 'ns':
- void build(vec<int>& ns) {
- for (int i = 0; i < heap.size(); i++)
- indices[heap[i]] = -1;
- heap.clear();
-
- for (int i = 0; i < ns.size(); i++){
- indices[ns[i]] = i;
- heap.push(ns[i]); }
-
- for (int i = heap.size() / 2 - 1; i >= 0; i--)
- percolateDown(i);
- }
-
- void clear(bool dealloc = false)
- {
- for (int i = 0; i < heap.size(); i++)
- indices[heap[i]] = -1;
- heap.clear(dealloc);
- }
-};
-
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/**************************************************************************************[IntTypes.h]
-Copyright (c) 2009-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_IntTypes_h
-#define BVMinisat_IntTypes_h
-
-#ifdef __sun
- // Not sure if there are newer versions that support C99 headers. The
- // needed features are implemented in the headers below though:
-
-# include <sys/int_types.h>
-# include <sys/int_fmtio.h>
-# include <sys/int_limits.h>
-
-#else
-
-// In contrast to the original MiniSat source code, we are including the
-// cstdint/cinttypes/climits headers instead of stdint.h/inttypes.h/limits.h
-// here. This ensures that the macros in cinttypes/inttypes.h, e.g., PRIi64,
-// are actually defined. The C99 standard suggested that those macros are only
-// defined for C++ code when __STDC_FORMAT_MACROS is defined. This was never
-// adopted by a C++ standard (https://en.cppreference.com/w/cpp/types/integer).
-// However, certain versions of mingw-w64 seem to require it with inttypes.h
-// but not cinttypes.
-# include <cstdint>
-# include <cinttypes>
-
-#endif
-
-#include <climits>
-
-//=================================================================================================
-
-#endif
+++ /dev/null
-/*******************************************************************************************[Map.h]
-Copyright (c) 2006-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_Map_h
-#define BVMinisat_Map_h
-
-#include "base/check.h"
-#include "prop/bvminisat/mtl/IntTypes.h"
-#include "prop/bvminisat/mtl/Vec.h"
-
-namespace cvc5 {
-namespace BVMinisat {
-
-//=================================================================================================
-// Default hash/equals functions
-//
-
-static inline uint32_t hash(uint32_t x){ return x; }
-static inline uint32_t hash(uint64_t x){ return (uint32_t)x; }
-static inline uint32_t hash(int32_t x) { return (uint32_t)x; }
-static inline uint32_t hash(int64_t x) { return (uint32_t)x; }
-
-template<class K> struct Hash { uint32_t operator()(const K& k) const { return hash(k); } };
-template<class K> struct Equal { bool operator()(const K& k1, const K& k2) const { return k1 == k2; } };
-
-template<class K> struct DeepHash { uint32_t operator()(const K* k) const { return hash(*k); } };
-template<class K> struct DeepEqual { bool operator()(const K* k1, const K* k2) const { return *k1 == *k2; } };
-
-
-
-//=================================================================================================
-// Some primes
-//
-
-static const int nprimes = 25;
-static const int primes [nprimes] = { 31, 73, 151, 313, 643, 1291, 2593, 5233, 10501, 21013, 42073, 84181, 168451, 337219, 674701, 1349473, 2699299, 5398891, 10798093, 21596719, 43193641, 86387383, 172775299, 345550609, 691101253 };
-
-//=================================================================================================
-// Hash table implementation of Maps
-//
-
-template<class K, class D, class H = Hash<K>, class E = Equal<K> >
-class Map {
- public:
- struct Pair { K key; D data; };
-
- private:
- H hash;
- E equals;
-
- vec<Pair>* table;
- int cap;
- int size;
-
- // Don't allow copying (error prone):
- Map<K, D, H, E>& operator=(Map<K, D, H, E>& other) { Assert(0); }
- Map(Map<K, D, H, E>& other) { Assert(0); }
-
- bool checkCap(int new_size) const { return new_size > cap; }
-
- int32_t index (const K& k) const { return hash(k) % cap; }
- void _insert (const K& k, const D& d) {
- vec<Pair>& ps = table[index(k)];
- ps.push(); ps.last().key = k; ps.last().data = d; }
-
- void rehash () {
- const vec<Pair>* old = table;
-
- int old_cap = cap;
- int newsize = primes[0];
- for (int i = 1; newsize <= cap && i < nprimes; i++)
- newsize = primes[i];
-
- table = new vec<Pair>[newsize];
- cap = newsize;
-
- for (int i = 0; i < old_cap; i++){
- for (int j = 0; j < old[i].size(); j++){
- _insert(old[i][j].key, old[i][j].data); }}
-
- delete [] old;
-
- // printf(" --- rehashing, old-cap=%d, new-cap=%d\n", cap, newsize);
- }
-
-
- public:
-
- Map () : table(NULL), cap(0), size(0) {}
- Map (const H& h, const E& e) : hash(h), equals(e), table(NULL), cap(0), size(0){}
- ~Map () { delete [] table; }
-
- // PRECONDITION: the key must already exist in the map.
- const D& operator [] (const K& k) const
- {
- Assert(size != 0);
- const D* res = NULL;
- const vec<Pair>& ps = table[index(k)];
- for (int i = 0; i < ps.size(); i++)
- if (equals(ps[i].key, k)) res = &ps[i].data;
- Assert(res != NULL);
- return *res;
- }
-
- // PRECONDITION: the key must already exist in the map.
- D& operator [] (const K& k)
- {
- Assert(size != 0);
- D* res = NULL;
- vec<Pair>& ps = table[index(k)];
- for (int i = 0; i < ps.size(); i++)
- if (equals(ps[i].key, k)) res = &ps[i].data;
- Assert(res != NULL);
- return *res;
- }
-
- // PRECONDITION: the key must *NOT* exist in the map.
- void insert (const K& k, const D& d) { if (checkCap(size+1)) rehash(); _insert(k, d); size++; }
- bool peek (const K& k, D& d) const {
- if (size == 0) return false;
- const vec<Pair>& ps = table[index(k)];
- for (int i = 0; i < ps.size(); i++)
- if (equals(ps[i].key, k)){
- d = ps[i].data;
- return true; }
- return false;
- }
-
- bool has (const K& k) const {
- if (size == 0) return false;
- const vec<Pair>& ps = table[index(k)];
- for (int i = 0; i < ps.size(); i++)
- if (equals(ps[i].key, k))
- return true;
- return false;
- }
-
- // PRECONDITION: the key must exist in the map.
- void remove(const K& k) {
- Assert(table != NULL);
- vec<Pair>& ps = table[index(k)];
- int j = 0;
- for (; j < ps.size() && !equals(ps[j].key, k); j++)
- ;
- Assert(j < ps.size());
- ps[j] = ps.last();
- ps.pop();
- size--;
- }
-
- void clear () {
- cap = size = 0;
- delete [] table;
- table = NULL;
- }
-
- int elems() const { return size; }
- int bucket_count() const { return cap; }
-
- // NOTE: the hash and equality objects are not moved by this method:
- void moveTo(Map& other){
- delete [] other.table;
-
- other.table = table;
- other.cap = cap;
- other.size = size;
-
- table = NULL;
- size = cap = 0;
- }
-
- // NOTE: given a bit more time, I could make a more C++-style iterator out of this:
- const vec<Pair>& bucket(int i) const { return table[i]; }
-};
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/*****************************************************************************************[Queue.h]
-Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_Queue_h
-#define BVMinisat_Queue_h
-
-#include "base/check.h"
-#include "prop/bvminisat/mtl/Vec.h"
-
-namespace cvc5 {
-namespace BVMinisat {
-
-//=================================================================================================
-
-template<class T>
-class Queue {
- vec<T> buf;
- int first;
- int end;
-
-public:
- typedef T Key;
-
- Queue() : buf(1), first(0), end(0) {}
-
- void clear (bool dealloc = false) { buf.clear(dealloc); buf.growTo(1); first = end = 0; }
- int size () const { return (end >= first) ? end - first : end - first + buf.size(); }
-
- const T& operator[](int index) const
- {
- Assert(index >= 0);
- Assert(index < size());
- return buf[(first + index) % buf.size()];
- }
- T& operator[](int index)
- {
- Assert(index >= 0);
- Assert(index < size());
- return buf[(first + index) % buf.size()];
- }
-
- T peek() const
- {
- Assert(first != end);
- return buf[first];
- }
- void pop()
- {
- Assert(first != end);
- first++;
- if (first == buf.size()) first = 0;
- }
- void insert(T elem) { // INVARIANT: buf[end] is always unused
- buf[end++] = elem;
- if (end == buf.size()) end = 0;
- if (first == end){ // Resize:
- vec<T> tmp((buf.size()*3 + 1) >> 1);
- //**/printf("queue alloc: %d elems (%.1f MB)\n", tmp.size(), tmp.size() * sizeof(T) / 1000000.0);
- int i = 0;
- for (int j = first; j < buf.size(); j++) tmp[i++] = buf[j];
- for (int j = 0 ; j < end ; j++) tmp[i++] = buf[j];
- first = 0;
- end = buf.size();
- tmp.moveTo(buf);
- }
- }
-};
-
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/******************************************************************************************[Sort.h]
-Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_Sort_h
-#define BVMinisat_Sort_h
-
-#include "prop/bvminisat/mtl/Vec.h"
-
-//=================================================================================================
-// Some sorting algorithms for vec's
-
-namespace cvc5 {
-namespace BVMinisat {
-
-template<class T>
-struct LessThan_default {
- bool operator () (T x, T y) { return x < y; }
-};
-
-
-template <class T, class LessThan>
-void selectionSort(T* array, int size, LessThan lt)
-{
- int i, j, best_i;
- T tmp;
-
- for (i = 0; i < size-1; i++){
- best_i = i;
- for (j = i+1; j < size; j++){
- if (lt(array[j], array[best_i]))
- best_i = j;
- }
- tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp;
- }
-}
-template <class T> static inline void selectionSort(T* array, int size) {
- selectionSort(array, size, LessThan_default<T>()); }
-
-template <class T, class LessThan>
-void sort(T* array, int size, LessThan lt)
-{
- if (size <= 15)
- selectionSort(array, size, lt);
-
- else{
- T pivot = array[size / 2];
- T tmp;
- int i = -1;
- int j = size;
-
- for(;;){
- do i++; while(lt(array[i], pivot));
- do j--; while(lt(pivot, array[j]));
-
- if (i >= j) break;
-
- tmp = array[i]; array[i] = array[j]; array[j] = tmp;
- }
-
- sort(array , i , lt);
- sort(&array[i], size-i, lt);
- }
-}
-template <class T> static inline void sort(T* array, int size) {
- sort(array, size, LessThan_default<T>()); }
-
-
-//=================================================================================================
-// For 'vec's:
-
-
-template <class T, class LessThan> void sort(vec<T>& v, LessThan lt) {
- sort((T*)v, v.size(), lt); }
-template <class T> void sort(vec<T>& v) {
- sort(v, LessThan_default<T>()); }
-
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/*******************************************************************************************[Vec.h]
-Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_Vec_h
-#define BVMinisat_Vec_h
-
-#include <new>
-
-#include "base/check.h"
-#include "prop/bvminisat/mtl/IntTypes.h"
-#include "prop/bvminisat/mtl/XAlloc.h"
-
-namespace cvc5 {
-namespace BVMinisat {
-
-//=================================================================================================
-// Automatically resizable arrays
-//
-// NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc)
-
-template<class T>
-class vec {
- T* data;
- int sz;
- int cap;
-
- // Don't allow copying (error prone):
- vec<T>& operator=(vec<T>& other)
- {
- Assert(0);
- return *this;
- }
- vec(vec<T>& other) { Assert(0); }
-
- // Helpers for calculating next capacity:
- static inline int imax (int x, int y) { int mask = (y-x) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); }
- //static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
- static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
-
-public:
- // Constructors:
- vec() : data(NULL) , sz(0) , cap(0) { }
- explicit vec(int size) : data(NULL) , sz(0) , cap(0) { growTo(size); }
- vec(int size, const T& pad) : data(NULL) , sz(0) , cap(0) { growTo(size, pad); }
- ~vec() { clear(true); }
-
- // Pointer to first element:
- operator T* (void) { return data; }
-
- // Size operations:
- int size (void) const { return sz; }
- void shrink(int nelems)
- {
- Assert(nelems <= sz);
- for (int i = 0; i < nelems; i++) sz--, data[sz].~T();
- }
- void shrink_(int nelems)
- {
- Assert(nelems <= sz);
- sz -= nelems;
- }
- int capacity (void) const { return cap; }
- void capacity (int min_cap);
- void growTo (int size);
- void growTo (int size, const T& pad);
- void clear (bool dealloc = false);
-
- // Stack interface:
- void push (void) { if (sz == cap) capacity(sz+1); new (&data[sz]) T(); sz++; }
- void push (const T& elem) { if (sz == cap) capacity(sz+1); data[sz++] = elem; }
- void push_(const T& elem)
- {
- Assert(sz < cap);
- data[sz++] = elem;
- }
- void pop(void)
- {
- Assert(sz > 0);
- sz--, data[sz].~T();
- }
- // NOTE: it seems possible that overflow can happen in the 'sz+1' expression of 'push()', but
- // in fact it can not since it requires that 'cap' is equal to INT_MAX. This in turn can not
- // happen given the way capacities are calculated (below). Essentially, all capacities are
- // even, but INT_MAX is odd.
-
- const T& last (void) const { return data[sz-1]; }
- T& last (void) { return data[sz-1]; }
-
- // Vector interface:
- const T& operator [] (int index) const { return data[index]; }
- T& operator [] (int index) { return data[index]; }
-
- // Duplicatation (preferred instead):
- void copyTo(vec<T>& copy) const { copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) copy[i] = data[i]; }
- void moveTo(vec<T>& dest) { dest.clear(true); dest.data = data; dest.sz = sz; dest.cap = cap; data = NULL; sz = 0; cap = 0; }
-};
-
-
-template<class T>
-void vec<T>::capacity(int min_cap) {
- if (cap >= min_cap) return;
- int add = imax((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1); // NOTE: grow by approximately 3/2
- if (add > INT_MAX - cap || (((data = (T*)::realloc(data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM))
- throw OutOfMemoryException();
- }
-
-
-template<class T>
-void vec<T>::growTo(int size, const T& pad) {
- if (sz >= size) return;
- capacity(size);
- for (int i = sz; i < size; i++) data[i] = pad;
- sz = size; }
-
-
-template<class T>
-void vec<T>::growTo(int size) {
- if (sz >= size) return;
- capacity(size);
- for (int i = sz; i < size; i++) new (&data[i]) T();
- sz = size; }
-
-
-template<class T>
-void vec<T>::clear(bool dealloc) {
- if (data != NULL){
- for (int i = 0; i < sz; i++) data[i].~T();
- sz = 0;
- if (dealloc) free(data), data = NULL, cap = 0; } }
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/****************************************************************************************[XAlloc.h]
-Copyright (c) 2009-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-
-#ifndef BVMinisat_XAlloc_h
-#define BVMinisat_XAlloc_h
-
-#include <errno.h>
-#include <stdlib.h>
-
-namespace cvc5 {
-namespace BVMinisat {
-
-//=================================================================================================
-// Simple layer on top of malloc/realloc to catch out-of-memory situtaions and provide some typing:
-
-class OutOfMemoryException{};
-static inline void* xrealloc(void *ptr, size_t size)
-{
- void* mem = realloc(ptr, size);
- if (mem == NULL && errno == ENOMEM){
- throw OutOfMemoryException();
- }else
- return mem;
-}
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/***********************************************************************************[SimpSolver.cc]
-Copyright (c) 2006, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#include "prop/bvminisat/simp/SimpSolver.h"
-
-#include "base/check.h"
-#include "options/bv_options.h"
-#include "options/smt_options.h"
-#include "proof/clause_id.h"
-#include "prop/bvminisat/mtl/Sort.h"
-#include "prop/bvminisat/utils/System.h"
-
-namespace cvc5 {
-namespace BVMinisat {
-
-//=================================================================================================
-// Options:
-
-
-static const char* _cat = "SIMP";
-
-static BoolOption opt_use_asymm (_cat, "asymm", "Shrink clauses by asymmetric branching.", false);
-static BoolOption opt_use_rcheck (_cat, "rcheck", "Check if a clause is already implied. (costly)", false);
-static BoolOption opt_use_elim (_cat, "elim", "Perform variable elimination.", true);
-static IntOption opt_grow (_cat, "grow", "Allow a variable elimination step to grow by a number of clauses.", 0);
-static IntOption opt_clause_lim (_cat, "cl-lim", "Variables are not eliminated if it produces a resolvent with a length above this limit. -1 means no limit", 20, IntRange(-1, INT32_MAX));
-static IntOption opt_subsumption_lim (_cat, "sub-lim", "Do not check if subsumption against a clause larger than this. -1 means no limit.", 1000, IntRange(-1, INT32_MAX));
-static DoubleOption opt_simp_garbage_frac(_cat, "simp-gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered during simplification.", 0.5, DoubleRange(0, false, HUGE_VAL, false));
-
-
-//=================================================================================================
-// Constructor/Destructor:
-
-SimpSolver::SimpSolver(cvc5::context::Context* context)
- : Solver(context),
- grow(opt_grow),
- clause_lim(opt_clause_lim),
- subsumption_lim(opt_subsumption_lim),
- simp_garbage_frac(opt_simp_garbage_frac),
- use_asymm(opt_use_asymm),
- use_rcheck(opt_use_rcheck),
- use_elim(opt_use_elim
- && cvc5::options::bitblastMode()
- == cvc5::options::BitblastMode::EAGER
- && !cvc5::options::produceModels()),
- merges(0),
- asymm_lits(0),
- eliminated_vars(0),
- elimorder(1),
- use_simplification(true),
- occurs(ClauseDeleted(ca)),
- elim_heap(ElimLt(n_occ)),
- bwdsub_assigns(0),
- n_touched(0)
-{
-
- vec<Lit> dummy(1,lit_Undef);
- ca.extra_clause_field = true; // NOTE: must happen before allocating the dummy clause below.
- bwdsub_tmpunit = ca.alloc(dummy);
- remove_satisfied = false;
-
- // add the initialization for all the internal variables
- for (int i = frozen.size(); i < vardata.size(); ++ i) {
- frozen .push(1);
- eliminated.push(0);
- if (use_simplification){
- n_occ .push(0);
- n_occ .push(0);
- occurs .init(i);
- touched .push(0);
- elim_heap .insert(i);
- }
- }
-
-}
-
-
-SimpSolver::~SimpSolver()
-{
- // cvc5::StatisticsRegistry::unregisterStat(&total_eliminate_time);
-}
-
-
-Var SimpSolver::newVar(bool sign, bool dvar, bool freeze) {
- Var v = Solver::newVar(sign, dvar);
-
- frozen .push((char)false);
- eliminated.push((char)false);
-
- if (use_simplification){
- n_occ .push(0);
- n_occ .push(0);
- occurs .init(v);
- touched .push(0);
- elim_heap .insert(v);
- if (freeze) {
- setFrozen(v, true);
- }
- }
- return v;
-}
-
-
-
-lbool SimpSolver::solve_(bool do_simp, bool turn_off_simp)
-{
- only_bcp = false;
-
- vec<Var> extra_frozen;
- lbool result = l_True;
-
- do_simp &= use_simplification;
-
- if (do_simp) {
- // Assumptions must be temporarily frozen to run variable elimination:
- for (int i = 0; i < assumptions.size(); i++){
- Var v = var(assumptions[i]);
-
- // If an assumption has been eliminated, remember it.
- Assert(!isEliminated(v));
-
- if (!frozen[v]){
- // Freeze and store.
- setFrozen(v, true);
- extra_frozen.push(v);
- } }
-
- if (do_simp && clause_added) {
- cancelUntil(0);
- result = lbool(eliminate(turn_off_simp));
- clause_added = false;
- }
- }
-
- if (result == l_True)
- result = Solver::solve_();
- else if (verbosity >= 1)
- printf("===============================================================================\n");
-
- if (do_simp)
- // Unfreeze the assumptions that were frozen:
- for (int i = 0; i < extra_frozen.size(); i++)
- setFrozen(extra_frozen[i], false);
-
- return result;
-}
-
-
-
-bool SimpSolver::addClause_(vec<Lit>& ps, ClauseId& id)
-{
-#ifdef CVC5_ASSERTIONS
- for (int i = 0; i < ps.size(); i++) Assert(!isEliminated(var(ps[i])));
-#endif
-
- int nclauses = clauses.size();
-
- if (use_rcheck && implied(ps))
- return true;
-
- if (!Solver::addClause_(ps, id))
- return false;
-
- if (use_simplification && clauses.size() == nclauses + 1){
- CRef cr = clauses.last();
- const Clause& clause = ca[cr];
-
- // NOTE: the clause is added to the queue immediately and then
- // again during 'gatherTouchedClauses()'. If nothing happens
- // in between, it will only be checked once. Otherwise, it may
- // be checked twice unnecessarily. This is an unfortunate
- // consequence of how backward subsumption is used to mimic
- // forward subsumption.
- subsumption_queue.insert(cr);
- for (int i = 0; i < clause.size(); i++)
- {
- occurs[var(clause[i])].push(cr);
- n_occ[toInt(clause[i])]++;
- touched[var(clause[i])] = 1;
- n_touched++;
- if (elim_heap.inHeap(var(clause[i])))
- elim_heap.increase(var(clause[i]));
- }
- }
-
- return true;
-}
-
-
-void SimpSolver::removeClause(CRef cr)
-{
- const Clause& clause = ca[cr];
-
- if (use_simplification)
- {
- for (int i = 0; i < clause.size(); i++)
- {
- n_occ[toInt(clause[i])]--;
- updateElimHeap(var(clause[i]));
- occurs.smudge(var(clause[i]));
- }
- }
- Solver::removeClause(cr);
-}
-
-
-bool SimpSolver::strengthenClause(CRef cr, Lit l)
-{
- Clause& clause = ca[cr];
- Assert(decisionLevel() == 0);
- Assert(use_simplification);
-
- // FIX: this is too inefficient but would be nice to have (properly
- // implemented) if (!find(subsumption_queue, &clause))
- subsumption_queue.insert(cr);
-
- if (clause.size() == 2)
- {
- removeClause(cr);
- clause.strengthen(l);
- }
- else
- {
- detachClause(cr, true);
- clause.strengthen(l);
- attachClause(cr);
- remove(occurs[var(l)], cr);
- n_occ[toInt(l)]--;
- updateElimHeap(var(l));
- }
-
- return clause.size() == 1 ? enqueue(clause[0]) && propagate() == CRef_Undef
- : true;
-}
-
-
-// Returns FALSE if clause is always satisfied ('out_clause' should not be used).
-bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause)
-{
- merges++;
- out_clause.clear();
-
- bool ps_smallest = _ps.size() < _qs.size();
- const Clause& ps = ps_smallest ? _qs : _ps;
- const Clause& qs = ps_smallest ? _ps : _qs;
-
- for (int i = 0; i < qs.size(); i++)
- {
- if (var(qs[i]) != v)
- {
- for (int j = 0; j < ps.size(); j++)
- {
- if (var(ps[j]) == var(qs[i]))
- {
- if (ps[j] == ~qs[i])
- return false;
- else
- goto next;
- }
- }
- out_clause.push(qs[i]);
- }
- next:;
- }
-
- for (int i = 0; i < ps.size(); i++)
- if (var(ps[i]) != v)
- out_clause.push(ps[i]);
-
- return true;
-}
-
-
-// Returns FALSE if clause is always satisfied.
-bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, int& size)
-{
- merges++;
-
- bool ps_smallest = _ps.size() < _qs.size();
- const Clause& ps = ps_smallest ? _qs : _ps;
- const Clause& qs = ps_smallest ? _ps : _qs;
- const Lit* __ps = (const Lit*)ps;
- const Lit* __qs = (const Lit*)qs;
-
- size = ps.size()-1;
-
- for (int i = 0; i < qs.size(); i++)
- {
- if (var(__qs[i]) != v)
- {
- for (int j = 0; j < ps.size(); j++)
- {
- if (var(__ps[j]) == var(__qs[i]))
- {
- if (__ps[j] == ~__qs[i])
- return false;
- else
- goto next;
- }
- }
- size++;
- }
- next:;
- }
-
- return true;
-}
-
-
-void SimpSolver::gatherTouchedClauses()
-{
- if (n_touched == 0) return;
-
- int i,j;
- for (i = j = 0; i < subsumption_queue.size(); i++)
- if (ca[subsumption_queue[i]].mark() == 0)
- ca[subsumption_queue[i]].mark(2);
-
- for (i = 0; i < touched.size(); i++)
- if (touched[i]){
- const vec<CRef>& cs = occurs.lookup(i);
- for (j = 0; j < cs.size(); j++)
- if (ca[cs[j]].mark() == 0){
- subsumption_queue.insert(cs[j]);
- ca[cs[j]].mark(2);
- }
- touched[i] = 0;
- }
-
- for (i = 0; i < subsumption_queue.size(); i++)
- if (ca[subsumption_queue[i]].mark() == 2)
- ca[subsumption_queue[i]].mark(0);
-
- n_touched = 0;
-}
-
-bool SimpSolver::implied(const vec<Lit>& clause)
-{
- Assert(decisionLevel() == 0);
-
- trail_lim.push(trail.size());
- for (int i = 0; i < clause.size(); i++)
- {
- if (value(clause[i]) == l_True)
- {
- cancelUntil(0);
- return false;
- }
- else if (value(clause[i]) != l_False)
- {
- Assert(value(clause[i]) == l_Undef);
- uncheckedEnqueue(~clause[i]);
- }
- }
-
- bool result = propagate() != CRef_Undef;
- cancelUntil(0);
- return result;
-}
-
-
-// Backward subsumption + backward subsumption resolution
-bool SimpSolver::backwardSubsumptionCheck(bool verbose)
-{
- int cnt = 0;
- int subsumed = 0;
- int deleted_literals = 0;
- Assert(decisionLevel() == 0);
-
- while (subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()){
-
- // Empty subsumption queue and return immediately on user-interrupt:
- if (asynch_interrupt){
- subsumption_queue.clear();
- bwdsub_assigns = trail.size();
- break; }
-
- // Check top-level assignments by creating a dummy clause and placing it in the queue:
- if (subsumption_queue.size() == 0 && bwdsub_assigns < trail.size()){
- Lit l = trail[bwdsub_assigns++];
- ca[bwdsub_tmpunit][0] = l;
- ca[bwdsub_tmpunit].calcAbstraction();
- subsumption_queue.insert(bwdsub_tmpunit); }
-
- CRef cr = subsumption_queue.peek(); subsumption_queue.pop();
- Clause& clause = ca[cr];
-
- if (clause.mark()) continue;
-
- if (verbose && verbosity >= 2 && cnt++ % 1000 == 0)
- printf("subsumption left: %10d (%10d subsumed, %10d deleted literals)\r", subsumption_queue.size(), subsumed, deleted_literals);
-
- Assert(clause.size() > 1
- || value(clause[0]) == l_True); // Unit-clauses should have been
- // propagated before this point.
-
- // Find best variable to scan:
- Var best = var(clause[0]);
- for (int i = 1; i < clause.size(); i++)
- if (occurs[var(clause[i])].size() < occurs[best].size())
- best = var(clause[i]);
-
- // Search all candidates:
- vec<CRef>& _cs = occurs.lookup(best);
- CRef* cs = (CRef*)_cs;
-
- for (int j = 0; j < _cs.size(); j++)
- if (clause.mark())
- break;
- else if (!ca[cs[j]].mark() && cs[j] != cr
- && (subsumption_lim == -1
- || ca[cs[j]].size() < subsumption_lim))
- {
- Lit l = clause.subsumes(ca[cs[j]]);
-
- if (l == lit_Undef)
- subsumed++, removeClause(cs[j]);
- else if (l != lit_Error)
- {
- deleted_literals++;
-
- if (!strengthenClause(cs[j], ~l)) return false;
-
- // Did current candidate get deleted from cs? Then check candidate
- // at index j again:
- if (var(l) == best) j--;
- }
- }
- }
-
- return true;
-}
-
-
-bool SimpSolver::asymm(Var v, CRef cr)
-{
- Clause& clause = ca[cr];
- Assert(decisionLevel() == 0);
-
- if (clause.mark() || satisfied(clause)) return true;
-
- trail_lim.push(trail.size());
- Lit l = lit_Undef;
- for (int i = 0; i < clause.size(); i++)
- if (var(clause[i]) != v && value(clause[i]) != l_False)
- uncheckedEnqueue(~clause[i]);
- else
- l = clause[i];
-
- if (propagate() != CRef_Undef)
- {
- cancelUntil(0);
- asymm_lits++;
- if (!strengthenClause(cr, l)) return false;
- }
- else
- cancelUntil(0);
-
- return true;
-}
-
-
-bool SimpSolver::asymmVar(Var v)
-{
- Assert(use_simplification);
-
- const vec<CRef>& cls = occurs.lookup(v);
-
- if (value(v) != l_Undef || cls.size() == 0) return true;
-
- for (int i = 0; i < cls.size(); i++)
- if (!asymm(v, cls[i])) return false;
-
- return backwardSubsumptionCheck();
-}
-
-
-static void mkElimClause(vec<uint32_t>& elimclauses, Lit x)
-{
- elimclauses.push(toInt(x));
- elimclauses.push(1);
-}
-
-static void mkElimClause(vec<uint32_t>& elimclauses, Var v, Clause& clause)
-{
- int first = elimclauses.size();
- int v_pos = -1;
-
- // Copy clause to elimclauses-vector. Remember position where the
- // variable 'v' occurs:
- for (int i = 0; i < clause.size(); i++)
- {
- elimclauses.push(toInt(clause[i]));
- if (var(clause[i]) == v) v_pos = i + first;
- }
- Assert(v_pos != -1);
-
- // Swap the first literal with the 'v' literal, so that the literal
- // containing 'v' will occur first in the clause:
- uint32_t tmp = elimclauses[v_pos];
- elimclauses[v_pos] = elimclauses[first];
- elimclauses[first] = tmp;
-
- // Store the length of the clause last:
- elimclauses.push(clause.size());
-}
-
-
-
-bool SimpSolver::eliminateVar(Var v)
-{
- Assert(!frozen[v]);
- Assert(!isEliminated(v));
- Assert(value(v) == l_Undef);
-
- // Split the occurrences into positive and negative:
- //
- const vec<CRef>& cls = occurs.lookup(v);
- vec<CRef> pos, neg;
- for (int i = 0; i < cls.size(); i++)
- (find(ca[cls[i]], mkLit(v)) ? pos : neg).push(cls[i]);
-
- // Check whether the increase in number of clauses stays within the allowed
- // ('grow'). Moreover, no clause must exceed the limit on the maximal clause
- // size (if it is set):
- //
- int cnt = 0;
- int clause_size = 0;
-
- for (int i = 0; i < pos.size(); i++)
- for (int j = 0; j < neg.size(); j++)
- if (merge(ca[pos[i]], ca[neg[j]], v, clause_size)
- && (++cnt > cls.size() + grow
- || (clause_lim != -1 && clause_size > clause_lim)))
- return true;
-
- // Delete and store old clauses:
- eliminated[v] = true;
- setDecisionVar(v, false);
- eliminated_vars++;
-
- if (pos.size() > neg.size())
- {
- for (int i = 0; i < neg.size(); i++)
- mkElimClause(elimclauses, v, ca[neg[i]]);
- mkElimClause(elimclauses, mkLit(v));
- }
- else
- {
- for (int i = 0; i < pos.size(); i++)
- mkElimClause(elimclauses, v, ca[pos[i]]);
- mkElimClause(elimclauses, ~mkLit(v));
- }
-
- for (int i = 0; i < cls.size(); i++) removeClause(cls[i]);
-
- // Produce clauses in cross product:
- vec<Lit>& resolvent = add_tmp;
- for (int i = 0; i < pos.size(); i++)
- for (int j = 0; j < neg.size(); j++) {
- ClauseId id = -1;
- if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) &&
- !addClause_(resolvent, id))
- return false;
- }
-
- // Free occurs list for this variable:
- occurs[v].clear(true);
-
- // Free watchers lists for this variable, if possible:
- if (watches[ mkLit(v)].size() == 0) watches[ mkLit(v)].clear(true);
- if (watches[~mkLit(v)].size() == 0) watches[~mkLit(v)].clear(true);
-
- return backwardSubsumptionCheck();
-}
-
-
-bool SimpSolver::substitute(Var v, Lit x)
-{
- Assert(!frozen[v]);
- Assert(!isEliminated(v));
- Assert(value(v) == l_Undef);
-
- if (!ok) return false;
-
- eliminated[v] = true;
- setDecisionVar(v, false);
- const vec<CRef>& cls = occurs.lookup(v);
-
- vec<Lit>& subst_clause = add_tmp;
- for (int i = 0; i < cls.size(); i++)
- {
- Clause& clause = ca[cls[i]];
-
- subst_clause.clear();
- for (int j = 0; j < clause.size(); j++)
- {
- Lit p = clause[j];
- subst_clause.push(var(p) == v ? x ^ sign(p) : p);
- }
-
- removeClause(cls[i]);
- ClauseId id;
- if (!addClause_(subst_clause, id)) return ok = false;
- }
-
- return true;
-}
-
-
-void SimpSolver::extendModel()
-{
- int i, j;
- Lit x;
-
- for (i = elimclauses.size()-1; i > 0; i -= j){
- for (j = elimclauses[i--]; j > 1; j--, i--)
- if (modelValue(toLit(elimclauses[i])) != l_False)
- goto next;
-
- x = toLit(elimclauses[i]);
- model[var(x)] = lbool(!sign(x));
- next:;
- }
-}
-
-
-bool SimpSolver::eliminate(bool turn_off_elim)
-{
- // cvc5::TimerStat::CodeTimer codeTimer(total_eliminate_time);
-
- if (!simplify())
- return false;
- else if (!use_simplification)
- return true;
-
- // Main simplification loop:
- //
- while (n_touched > 0 || bwdsub_assigns < trail.size() || elim_heap.size() > 0)
- {
- gatherTouchedClauses();
- // printf(" ## (time = %6.2f s) BWD-SUB: queue = %d, trail = %d\n",
- // cpuTime(), subsumption_queue.size(), trail.size() - bwdsub_assigns);
- if ((subsumption_queue.size() > 0 || bwdsub_assigns < trail.size())
- && !backwardSubsumptionCheck(true))
- {
- ok = false;
- goto cleanup;
- }
-
- // Empty elim_heap and return immediately on user-interrupt:
- if (asynch_interrupt)
- {
- Assert(bwdsub_assigns == trail.size());
- Assert(subsumption_queue.size() == 0);
- Assert(n_touched == 0);
- elim_heap.clear();
- goto cleanup;
- }
-
- // printf(" ## (time = %6.2f s) ELIM: vars = %d\n", cpuTime(),
- // elim_heap.size());
- for (int cnt = 0; !elim_heap.empty(); cnt++)
- {
- Var elim = elim_heap.removeMin();
-
- if (asynch_interrupt) break;
-
- if (isEliminated(elim) || value(elim) != l_Undef) continue;
-
- if (verbosity >= 2 && cnt % 100 == 0)
- printf("elimination left: %10d\r", elim_heap.size());
-
- if (use_asymm)
- {
- // Temporarily freeze variable. Otherwise, it would immediately end up
- // on the queue again:
- bool was_frozen = frozen[elim];
- frozen[elim] = true;
- if (!asymmVar(elim))
- {
- ok = false;
- goto cleanup;
- }
- frozen[elim] = was_frozen;
- }
-
- // At this point, the variable may have been set by assymetric branching,
- // so check it again. Also, don't eliminate frozen variables:
- if (use_elim && value(elim) == l_Undef && !frozen[elim]
- && !eliminateVar(elim))
- {
- ok = false;
- goto cleanup;
- }
-
- checkGarbage(simp_garbage_frac);
- }
-
- Assert(subsumption_queue.size() == 0);
- }
- cleanup:
-
- // If no more simplification is needed, free all simplification-related data structures:
- if (turn_off_elim){
- touched .clear(true);
- occurs .clear(true);
- n_occ .clear(true);
- elim_heap.clear(true);
- subsumption_queue.clear(true);
-
- use_simplification = false;
- remove_satisfied = true;
- ca.extra_clause_field = false;
-
- // Force full cleanup (this is safe and desirable since it only happens once):
- rebuildOrderHeap();
- garbageCollect();
- }else{
- // Cheaper cleanup:
- cleanUpClauses(); // TODO: can we make 'cleanUpClauses()' not be linear in the problem size somehow?
- checkGarbage();
- }
-
- if (verbosity >= 1 && elimclauses.size() > 0)
- printf(
- "| Eliminated clauses: %10.2f Mb "
- " |\n",
- double(elimclauses.size() * sizeof(uint32_t)) / (1024 * 1024));
-
- return ok;
-
-
-
-}
-
-
-void SimpSolver::cleanUpClauses()
-{
- occurs.cleanAll();
- int i,j;
- for (i = j = 0; i < clauses.size(); i++)
- if (ca[clauses[i]].mark() == 0)
- clauses[j++] = clauses[i];
- clauses.shrink(i - j);
-}
-
-
-//=================================================================================================
-// Garbage Collection methods:
-
-
-void SimpSolver::relocAll(ClauseAllocator& to)
-{
- if (!use_simplification) return;
-
- // All occurs lists:
- //
- for (int i = 0; i < nVars(); i++){
- vec<CRef>& cs = occurs[i];
- for (int j = 0; j < cs.size(); j++)
- ca.reloc(cs[j], to);
- }
-
- // Subsumption queue:
- //
- for (int i = 0; i < subsumption_queue.size(); i++)
- ca.reloc(subsumption_queue[i], to);
-
- // Temporary clause:
- //
- ca.reloc(bwdsub_tmpunit, to);
-}
-
-
-void SimpSolver::garbageCollect()
-{
- // Initialize the next region to a size corresponding to the estimated utilization degree. This
- // is not precise but should avoid some unnecessary reallocations for the new region:
- ClauseAllocator to(ca.size() - ca.wasted());
-
- cleanUpClauses();
- to.extra_clause_field = ca.extra_clause_field; // NOTE: this is important to keep (or lose) the extra fields.
- relocAll(to);
- Solver::relocAll(to);
- if (verbosity >= 2)
- printf(
- "| Garbage collection: %12d bytes => %12d bytes |\n",
- ca.size() * ClauseAllocator::Unit_Size,
- to.size() * ClauseAllocator::Unit_Size);
- to.moveTo(ca);
-}
-
-} // namespace BVMinisat
-} // namespace cvc5
+++ /dev/null
-/************************************************************************************[SimpSolver.h]
-Copyright (c) 2006, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_SimpSolver_h
-#define BVMinisat_SimpSolver_h
-
-#include "base/check.h"
-#include "proof/clause_id.h"
-#include "prop/bvminisat/core/Solver.h"
-#include "prop/bvminisat/mtl/Queue.h"
-
-namespace cvc5 {
-
-namespace context {
-class Context;
-}
-
-namespace BVMinisat {
-
-//=================================================================================================
-
-
-class SimpSolver : public Solver {
- public:
- // Constructor/Destructor:
- //
- SimpSolver(cvc5::context::Context* context);
- ~SimpSolver();
-
- // Problem specification:
- //
- Var newVar(bool polarity = true, bool dvar = true, bool freeze = false);
- bool addClause(const vec<Lit>& ps, ClauseId& id);
- bool addEmptyClause(); // Add the empty clause to the solver.
- bool addClause(Lit p, ClauseId& id); // Add a unit clause to the solver.
- bool addClause(Lit p,
- Lit q,
- ClauseId& id); // Add a binary clause to the solver.
- bool addClause(Lit p,
- Lit q,
- Lit r,
- ClauseId& id); // Add a ternary clause to the solver.
- bool addClause_(vec<Lit>& ps, ClauseId& id);
- bool substitute(Var v, Lit x); // Replace all occurrences of v with x (may
- // cause a contradiction).
-
- // Variable mode:
- //
- void setFrozen(Var v,
- bool b); // If a variable is frozen it will not be eliminated.
- bool isEliminated(Var v) const;
-
- // Solving:
- //
- lbool solve(const vec<Lit>& assumps,
- bool do_simp = true,
- bool turn_off_simp = false);
- lbool solveLimited(const vec<Lit>& assumps,
- bool do_simp = true,
- bool turn_off_simp = false);
- lbool solveLimited(bool do_simp = true, bool turn_off_simp = false);
- lbool solve(bool do_simp = true, bool turn_off_simp = false);
- lbool solve(Lit p, bool do_simp = true, bool turn_off_simp = false);
- lbool solve(Lit p, Lit q, bool do_simp = true, bool turn_off_simp = false);
- lbool solve(
- Lit p, Lit q, Lit r, bool do_simp = true, bool turn_off_simp = false);
- bool eliminate(bool turn_off_elim = false); // Perform variable elimination
- // based simplification.
-
- // Memory managment:
- //
- void garbageCollect() override;
-
- // Generate a (possibly simplified) DIMACS file:
- //
-#if 0
- void toDimacs (const char* file, const vec<Lit>& assumps);
- void toDimacs (const char* file);
- void toDimacs (const char* file, Lit p);
- void toDimacs (const char* file, Lit p, Lit q);
- void toDimacs (const char* file, Lit p, Lit q, Lit r);
-#endif
-
- // Mode of operation:
- //
- int grow; // Allow a variable elimination step to grow by a number of clauses (default to zero).
- int clause_lim; // Variables are not eliminated if it produces a resolvent with a length above this limit.
- // -1 means no limit.
- int subsumption_lim; // Do not check if subsumption against a clause larger than this. -1 means no limit.
- double simp_garbage_frac; // A different limit for when to issue a GC during simplification (Also see 'garbage_frac').
-
- bool use_asymm; // Shrink clauses by asymmetric branching.
- bool use_rcheck; // Check if a clause is already implied. Prett costly, and subsumes subsumptions :)
- bool use_elim; // Perform variable elimination.
-
- // Statistics:
- //
- int merges;
- int asymm_lits;
- int64_t eliminated_vars;
- // cvc5::TimerStat total_eliminate_time;
-
- protected:
-
- // Helper structures:
- //
- struct ElimLt {
- const vec<int>& n_occ;
- explicit ElimLt(const vec<int>& no) : n_occ(no) {}
-
- // TODO: are 64-bit operations here noticably bad on 32-bit platforms? Could use a saturating
- // 32-bit implementation instead then, but this will have to do for now.
- uint64_t cost (Var x) const { return (uint64_t)n_occ[toInt(mkLit(x))] * (uint64_t)n_occ[toInt(~mkLit(x))]; }
- bool operator()(Var x, Var y) const { return cost(x) < cost(y); }
-
- // TODO: investigate this order alternative more.
- // bool operator()(Var x, Var y) const {
- // int c_x = cost(x);
- // int c_y = cost(y);
- // return c_x < c_y || c_x == c_y && x < y; }
- };
-
- struct ClauseDeleted {
- const ClauseAllocator& ca;
- explicit ClauseDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
- bool operator()(const CRef& cr) const { return ca[cr].mark() == 1; } };
-
- // Solver state:
- //
- int elimorder;
- bool use_simplification;
- vec<uint32_t> elimclauses;
- vec<char> touched;
- OccLists<Var, vec<CRef>, ClauseDeleted>
- occurs;
- vec<int> n_occ;
- Heap<ElimLt> elim_heap;
- Queue<CRef> subsumption_queue;
- vec<char> frozen;
- vec<char> eliminated;
- int bwdsub_assigns;
- int n_touched;
-
- // Temporaries:
- //
- CRef bwdsub_tmpunit;
-
- // Main internal methods:
- //
- lbool solve_ (bool do_simp = true, bool turn_off_simp = false);
- bool asymm (Var v, CRef cr);
- bool asymmVar (Var v);
- void updateElimHeap (Var v);
- void gatherTouchedClauses ();
- bool merge (const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause);
- bool merge (const Clause& _ps, const Clause& _qs, Var v, int& size);
- bool backwardSubsumptionCheck (bool verbose = false);
- bool eliminateVar (Var v);
- void extendModel ();
-
- void removeClause (CRef cr);
- bool strengthenClause (CRef cr, Lit l);
- void cleanUpClauses ();
- bool implied (const vec<Lit>& c);
- void relocAll (ClauseAllocator& to);
-};
-
-
-//=================================================================================================
-// Implementation of inline methods:
-
-
-inline bool SimpSolver::isEliminated (Var v) const { return eliminated[v]; }
-inline void SimpSolver::updateElimHeap(Var v) {
- Assert(use_simplification);
- // if (!frozen[v] && !isEliminated(v) && value(v) == l_Undef)
- if (elim_heap.inHeap(v)
- || (!frozen[v] && !isEliminated(v) && value(v) == l_Undef))
- elim_heap.update(v);
-}
-
-inline bool SimpSolver::addClause (const vec<Lit>& ps, ClauseId& id) { ps.copyTo(add_tmp); return addClause_(add_tmp, id); }
-inline bool SimpSolver::addEmptyClause() { add_tmp.clear(); ClauseId id; return addClause_(add_tmp, id); }
-inline bool SimpSolver::addClause (Lit p, ClauseId& id) { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp, id); }
-inline bool SimpSolver::addClause (Lit p, Lit q, ClauseId& id) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp, id); }
-inline bool SimpSolver::addClause (Lit p, Lit q, Lit r, ClauseId& id) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp, id); }
-inline void SimpSolver::setFrozen (Var v, bool b) { frozen[v] = (char)b; if (use_simplification && !b) { updateElimHeap(v); } }
-
-inline lbool SimpSolver::solve ( bool do_simp, bool turn_off_simp) {
- budgetOff();
- return solve_(do_simp, turn_off_simp);
- }
-inline lbool SimpSolver::solve (Lit p , bool do_simp, bool turn_off_simp) {
- budgetOff();
- assumptions.push(p);
- return solve_(do_simp, turn_off_simp);
- }
-inline lbool SimpSolver::solve (Lit p, Lit q, bool do_simp, bool turn_off_simp) {
- budgetOff();
- assumptions.push(p);
- assumptions.push(q);
- return solve_(do_simp, turn_off_simp);
- }
-inline lbool SimpSolver::solve (Lit p, Lit q, Lit r, bool do_simp, bool turn_off_simp) {
- budgetOff();
- assumptions.push(p);
- assumptions.push(q);
- assumptions.push(r);
- return solve_(do_simp, turn_off_simp);
- }
-inline lbool SimpSolver::solve (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){
- budgetOff(); assumps.copyTo(assumptions);
- return solve_(do_simp, turn_off_simp);
-}
-
-inline lbool SimpSolver::solveLimited (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){
- assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp); }
-
-inline lbool SimpSolver::solveLimited (bool do_simp, bool turn_off_simp){
- return solve_(do_simp, turn_off_simp); }
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/**************************************************************************************[Options.cc]
-Copyright (c) 2008-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#include "prop/bvminisat/utils/Options.h"
-#include "prop/bvminisat/mtl/Sort.h"
-#include "prop/bvminisat/utils/ParseUtils.h"
-
-namespace cvc5 {
-namespace BVMinisat {
-
-void BVMinisat::parseOptions(int& argc, char** argv, bool strict)
-{
- int i, j;
- for (i = j = 1; i < argc; i++){
- const char* str = argv[i];
- if (match(str, "--") && match(str, Option::getHelpPrefixString()) && match(str, "help")){
- if (*str == '\0')
- printUsageAndExit(argc, argv);
- else if (match(str, "-verb"))
- printUsageAndExit(argc, argv, true);
- } else {
- bool parsed_ok = false;
-
- for (int k = 0; !parsed_ok && k < Option::getOptionList().size(); k++){
- parsed_ok = Option::getOptionList()[k]->parse(argv[i]);
-
- // fprintf(stderr, "checking %d: %s against flag <%s> (%s)\n", i, argv[i], Option::getOptionList()[k]->name, parsed_ok ? "ok" : "skip");
- }
-
- if (!parsed_ok)
- if (strict && match(argv[i], "-"))
- fprintf(stderr, "ERROR! Unknown flag \"%s\". Use '--%shelp' for help.\n", argv[i], Option::getHelpPrefixString()), exit(1);
- else
- argv[j++] = argv[i];
- }
- }
-
- argc -= (i - j);
-}
-
-
-void BVMinisat::setUsageHelp (const char* str){ Option::getUsageString() = str; }
-void BVMinisat::setHelpPrefixStr (const char* str){ Option::getHelpPrefixString() = str; }
-void BVMinisat::printUsageAndExit (int argc, char** argv, bool verbose)
-{
- const char* usage = Option::getUsageString();
- if (usage != NULL)
- fprintf(stderr, usage, argv[0]);
-
- sort(Option::getOptionList(), Option::OptionLt());
-
- const char* prev_cat = NULL;
- const char* prev_type = NULL;
-
- for (int i = 0; i < Option::getOptionList().size(); i++){
- const char* cat = Option::getOptionList()[i]->category;
- const char* type = Option::getOptionList()[i]->type_name;
-
- if (cat != prev_cat)
- fprintf(stderr, "\n%s OPTIONS:\n\n", cat);
- else if (type != prev_type)
- fprintf(stderr, "\n");
-
- Option::getOptionList()[i]->help(verbose);
-
- prev_cat = Option::getOptionList()[i]->category;
- prev_type = Option::getOptionList()[i]->type_name;
- }
-
- fprintf(stderr, "\nHELP OPTIONS:\n\n");
- fprintf(stderr, " --%shelp Print help message.\n", Option::getHelpPrefixString());
- fprintf(stderr, " --%shelp-verb Print verbose help message.\n", Option::getHelpPrefixString());
- fprintf(stderr, "\n");
- exit(0);
-}
-
-} // namespace BVMinisat
-} // namespace cvc5
+++ /dev/null
-/***************************************************************************************[Options.h]
-Copyright (c) 2008-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_Options_h
-#define BVMinisat_Options_h
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <math.h>
-#include <string.h>
-
-#include "prop/bvminisat/mtl/IntTypes.h"
-#include "prop/bvminisat/mtl/Vec.h"
-#include "prop/bvminisat/utils/ParseUtils.h"
-
-namespace cvc5 {
-namespace BVMinisat {
-
-//==================================================================================================
-// Top-level option parse/help functions:
-
-
-extern void parseOptions (int& argc, char** argv, bool strict = false);
-extern void printUsageAndExit(int argc, char** argv, bool verbose = false);
-extern void setUsageHelp (const char* str);
-extern void setHelpPrefixStr (const char* str);
-
-
-//==================================================================================================
-// Options is an abstract class that gives the interface for all types options:
-
-
-class Option
-{
- protected:
- const char* name;
- const char* description;
- const char* category;
- const char* type_name;
-
- static vec<Option*>& getOptionList () { static vec<Option*> options; return options; }
- static const char*& getUsageString() { static const char* usage_str; return usage_str; }
- static const char*& getHelpPrefixString() { static const char* help_prefix_str = ""; return help_prefix_str; }
-
- struct OptionLt {
- bool operator()(const Option* x, const Option* y) {
- int test1 = strcmp(x->category, y->category);
- return test1 < 0 || (test1 == 0 && strcmp(x->type_name, y->type_name) < 0);
- }
- };
-
- Option(const char* name_,
- const char* desc_,
- const char* cate_,
- const char* type_) :
- name (name_)
- , description(desc_)
- , category (cate_)
- , type_name (type_)
- {
- getOptionList().push(this);
- }
-
- public:
- virtual ~Option() {}
-
- virtual bool parse (const char* str) = 0;
- virtual void help (bool verbose = false) = 0;
-
- friend void parseOptions (int& argc, char** argv, bool strict);
- friend void printUsageAndExit (int argc, char** argv, bool verbose);
- friend void setUsageHelp (const char* str);
- friend void setHelpPrefixStr (const char* str);
-};
-
-
-//==================================================================================================
-// Range classes with specialization for floating types:
-
-
-struct IntRange {
- int begin;
- int end;
- IntRange(int b, int e) : begin(b), end(e) {}
-};
-
-struct Int64Range {
- int64_t begin;
- int64_t end;
- Int64Range(int64_t b, int64_t e) : begin(b), end(e) {}
-};
-
-struct DoubleRange {
- double begin;
- double end;
- bool begin_inclusive;
- bool end_inclusive;
- DoubleRange(double b, bool binc, double e, bool einc) : begin(b), end(e), begin_inclusive(binc), end_inclusive(einc) {}
-};
-
-
-//==================================================================================================
-// Double options:
-
-
-class DoubleOption : public Option
-{
- protected:
- DoubleRange range;
- double value;
-
- public:
- DoubleOption(const char* c, const char* n, const char* d, double def = double(), DoubleRange r = DoubleRange(-HUGE_VAL, false, HUGE_VAL, false))
- : Option(n, d, c, "<double>"), range(r), value(def) {
- // FIXME: set LC_NUMERIC to "C" to make sure that strtof/strtod parses decimal point correctly.
- }
-
- operator double (void) const { return value; }
- operator double& (void) { return value; }
- DoubleOption& operator=(double x) { value = x; return *this; }
-
- bool parse(const char* str) override
- {
- const char* span = str;
-
- if (!match(span, "-") || !match(span, name) || !match(span, "="))
- return false;
-
- char* end;
- double tmp = strtod(span, &end);
-
- if (end == NULL)
- return false;
- else if (tmp >= range.end && (!range.end_inclusive || tmp != range.end))
- {
- fprintf(stderr,
- "ERROR! value <%s> is too large for option \"%s\".\n",
- span,
- name);
- exit(1);
- }
- else if (tmp <= range.begin
- && (!range.begin_inclusive || tmp != range.begin))
- {
- fprintf(stderr,
- "ERROR! value <%s> is too small for option \"%s\".\n",
- span,
- name);
- exit(1);
- }
-
- value = tmp;
- // fprintf(stderr, "READ VALUE: %g\n", value);
-
- return true;
- }
-
- void help(bool verbose = false) override
- {
- fprintf(stderr,
- " -%-12s = %-8s %c%4.2g .. %4.2g%c (default: %g)\n",
- name,
- type_name,
- range.begin_inclusive ? '[' : '(',
- range.begin,
- range.end,
- range.end_inclusive ? ']' : ')',
- value);
- if (verbose)
- {
- fprintf(stderr, "\n %s\n", description);
- fprintf(stderr, "\n");
- }
- }
-};
-
-
-//==================================================================================================
-// Int options:
-
-
-class IntOption : public Option
-{
- protected:
- IntRange range;
- int32_t value;
-
- public:
- IntOption(const char* c, const char* n, const char* d, int32_t def = int32_t(), IntRange r = IntRange(INT32_MIN, INT32_MAX))
- : Option(n, d, c, "<int32>"), range(r), value(def) {}
-
- operator int32_t (void) const { return value; }
- operator int32_t& (void) { return value; }
- IntOption& operator= (int32_t x) { value = x; return *this; }
-
- bool parse(const char* str) override
- {
- const char* span = str;
-
- if (!match(span, "-") || !match(span, name) || !match(span, "="))
- return false;
-
- char* end;
- int32_t tmp = strtol(span, &end, 10);
-
- if (end == NULL)
- return false;
- else if (tmp > range.end)
- {
- fprintf(stderr,
- "ERROR! value <%s> is too large for option \"%s\".\n",
- span,
- name);
- exit(1);
- }
- else if (tmp < range.begin)
- {
- fprintf(stderr,
- "ERROR! value <%s> is too small for option \"%s\".\n",
- span,
- name);
- exit(1);
- }
-
- value = tmp;
-
- return true;
- }
-
- void help(bool verbose = false) override
- {
- fprintf(stderr, " -%-12s = %-8s [", name, type_name);
- if (range.begin == INT32_MIN)
- fprintf(stderr, "imin");
- else
- fprintf(stderr, "%4d", range.begin);
-
- fprintf(stderr, " .. ");
- if (range.end == INT32_MAX)
- fprintf(stderr, "imax");
- else
- fprintf(stderr, "%4d", range.end);
-
- fprintf(stderr, "] (default: %d)\n", value);
- if (verbose)
- {
- fprintf(stderr, "\n %s\n", description);
- fprintf(stderr, "\n");
- }
- }
-};
-
-
-// Leave this out for visual C++ until Microsoft implements C99 and gets support for strtoll.
-#ifndef _MSC_VER
-
-class Int64Option : public Option
-{
- protected:
- Int64Range range;
- int64_t value;
-
- public:
- Int64Option(const char* c, const char* n, const char* d, int64_t def = int64_t(), Int64Range r = Int64Range(INT64_MIN, INT64_MAX))
- : Option(n, d, c, "<int64>"), range(r), value(def) {}
-
- operator int64_t (void) const { return value; }
- operator int64_t& (void) { return value; }
- Int64Option& operator= (int64_t x) { value = x; return *this; }
-
- bool parse(const char* str) override
- {
- const char* span = str;
-
- if (!match(span, "-") || !match(span, name) || !match(span, "="))
- return false;
-
- char* end;
- int64_t tmp = strtoll(span, &end, 10);
-
- if (end == NULL)
- return false;
- else if (tmp > range.end)
- {
- fprintf(stderr,
- "ERROR! value <%s> is too large for option \"%s\".\n",
- span,
- name);
- exit(1);
- }
- else if (tmp < range.begin)
- {
- fprintf(stderr,
- "ERROR! value <%s> is too small for option \"%s\".\n",
- span,
- name);
- exit(1);
- }
-
- value = tmp;
-
- return true;
- }
-
- void help(bool verbose = false) override
- {
- fprintf(stderr, " -%-12s = %-8s [", name, type_name);
- if (range.begin == INT64_MIN)
- fprintf(stderr, "imin");
- else
- fprintf(stderr, "%4" PRIi64, range.begin);
-
- fprintf(stderr, " .. ");
- if (range.end == INT64_MAX)
- fprintf(stderr, "imax");
- else
- fprintf(stderr, "%4" PRIi64, range.end);
-
- fprintf(stderr, "] (default: %" PRIi64 ")\n", value);
- if (verbose)
- {
- fprintf(stderr, "\n %s\n", description);
- fprintf(stderr, "\n");
- }
- }
-};
-#endif
-
-//==================================================================================================
-// String option:
-
-
-class StringOption : public Option
-{
- const char* value;
- public:
- StringOption(const char* c, const char* n, const char* d, const char* def = NULL)
- : Option(n, d, c, "<string>"), value(def) {}
-
- operator const char* (void) const { return value; }
- operator const char*& (void) { return value; }
- StringOption& operator= (const char* x) { value = x; return *this; }
-
- bool parse(const char* str) override
- {
- const char* span = str;
-
- if (!match(span, "-") || !match(span, name) || !match(span, "="))
- return false;
-
- value = span;
- return true;
- }
-
- void help(bool verbose = false) override
- {
- fprintf(stderr, " -%-10s = %8s\n", name, type_name);
- if (verbose)
- {
- fprintf(stderr, "\n %s\n", description);
- fprintf(stderr, "\n");
- }
- }
-};
-
-
-//==================================================================================================
-// Bool option:
-
-
-class BoolOption : public Option
-{
- bool value;
-
- public:
- BoolOption(const char* c, const char* n, const char* d, bool v)
- : Option(n, d, c, "<bool>"), value(v) {}
-
- operator bool (void) const { return value; }
- operator bool& (void) { return value; }
- BoolOption& operator=(bool b) { value = b; return *this; }
-
- bool parse(const char* str) override
- {
- const char* span = str;
-
- if (match(span, "-"))
- {
- bool b = !match(span, "no-");
-
- if (strcmp(span, name) == 0)
- {
- value = b;
- return true;
- }
- }
-
- return false;
- }
-
- void help(bool verbose = false) override
- {
- fprintf(stderr, " -%s, -no-%s", name, name);
-
- for (uint32_t i = 0; i < 32 - strlen(name) * 2; i++) fprintf(stderr, " ");
-
- fprintf(stderr, " ");
- fprintf(stderr, "(default: %s)\n", value ? "on" : "off");
- if (verbose)
- {
- fprintf(stderr, "\n %s\n", description);
- fprintf(stderr, "\n");
- }
- }
-};
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/************************************************************************************[ParseUtils.h]
-Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_ParseUtils_h
-#define BVMinisat_ParseUtils_h
-
-#include <stdlib.h>
-#include <stdio.h>
-
-//#include <zlib.h>
-#include <unistd.h>
-
-namespace cvc5 {
-namespace BVMinisat {
-
-//-------------------------------------------------------------------------------------------------
-// A simple buffered character stream class:
-
-static const int buffer_size = 1048576;
-
-
-class StreamBuffer {
- int in;
- unsigned char buf[buffer_size];
- int pos;
- int size;
-
- void assureLookahead() {
- if (pos >= size) {
- pos = 0;
- size = read(in, buf, sizeof(buf)); } }
-
-public:
- explicit StreamBuffer(int i) : in(i), pos(0), size(0) { assureLookahead(); }
-
- int operator * () const { return (pos >= size) ? EOF : buf[pos]; }
- void operator ++ () { pos++; assureLookahead(); }
- int position () const { return pos; }
-};
-
-
-//-------------------------------------------------------------------------------------------------
-// End-of-file detection functions for StreamBuffer and char*:
-
-
-static inline bool isEof(StreamBuffer& in) { return *in == EOF; }
-static inline bool isEof(const char* in) { return *in == '\0'; }
-
-//-------------------------------------------------------------------------------------------------
-// Generic parse functions parametrized over the input-stream type.
-
-
-template<class B>
-static void skipWhitespace(B& in) {
- while ((*in >= 9 && *in <= 13) || *in == 32)
- ++in; }
-
-
-template<class B>
-static void skipLine(B& in) {
- for (;;){
- if (isEof(in)) return;
- if (*in == '\n') { ++in; return; }
- ++in; } }
-
-
-template<class B>
-static int parseInt(B& in) {
- int val = 0;
- bool neg = false;
- skipWhitespace(in);
- if (*in == '-') neg = true, ++in;
- else if (*in == '+') ++in;
- if (*in < '0' || *in > '9') fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
- while (*in >= '0' && *in <= '9')
- val = val*10 + (*in - '0'),
- ++in;
- return neg ? -val : val; }
-
-
-// String matching: in case of a match the input iterator will be advanced the corresponding
-// number of characters.
-template<class B>
-static bool match(B& in, const char* str) {
- int i;
- for (i = 0; str[i] != '\0'; i++)
- if (in[i] != str[i])
- return false;
-
- in += i;
-
- return true;
-}
-
-// String matching: consumes characters eagerly, but does not require random access iterator.
-template<class B>
-static bool eagerMatch(B& in, const char* str) {
- for (; *str != '\0'; ++str, ++in)
- if (*str != *in)
- return false;
- return true; }
-
-
-//=================================================================================================
-} // namespace BVMinisat
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/***************************************************************************************[System.cc]
-Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#include "prop/bvminisat/utils/System.h"
-
-#if defined(__linux__)
-
-#include <stdio.h>
-#include <stdlib.h>
-
-namespace cvc5 {
-namespace BVMinisat {
-
-// TODO: split the memory reading functions into two: one for reading high-watermark of RSS, and
-// one for reading the current virtual memory size.
-
-static inline int memReadStat(int field)
-{
- char name[256];
- pid_t pid = getpid();
- int value;
-
- sprintf(name, "/proc/%d/statm", pid);
- FILE* in = fopen(name, "rb");
- if (in == NULL) return 0;
-
- for (; field >= 0; field--)
- if (fscanf(in, "%d", &value) != 1)
- printf("ERROR! Failed to parse memory statistics from \"/proc\".\n"), exit(1);
- fclose(in);
- return value;
-}
-
-
-static inline int memReadPeak(void)
-{
- char name[256];
- pid_t pid = getpid();
-
- sprintf(name, "/proc/%d/status", pid);
- FILE* in = fopen(name, "rb");
- if (in == NULL) return 0;
-
- // Find the correct line, beginning with "VmPeak:":
- int peak_kb = 0;
- while (!feof(in) && fscanf(in, "VmPeak: %d kB", &peak_kb) != 1)
- while (!feof(in) && fgetc(in) != '\n')
- ;
- fclose(in);
-
- return peak_kb;
-}
-
-double BVMinisat::memUsed() { return (double)memReadStat(0) * (double)getpagesize() / (1024*1024); }
-double BVMinisat::memUsedPeak() {
- double peak = memReadPeak() / 1024;
- return peak == 0 ? memUsed() : peak; }
-
-#elif defined(__FreeBSD__)
-
-double BVMinisat::memUsed(void) {
- struct rusage ru;
- getrusage(RUSAGE_SELF, &ru);
- return (double)ru.ru_maxrss / 1024; }
-double MiniSat::memUsedPeak(void) { return memUsed(); }
-
-
-#elif defined(__APPLE__)
-#include <malloc/malloc.h>
-
-double BVMinisat::memUsed(void) {
- malloc_statistics_t t;
- malloc_zone_statistics(NULL, &t);
- return (double)t.max_size_in_use / (1024*1024); }
-
-#else
-double BVMinisat::memUsed() {
- return 0; }
-#endif
-
-} /* cvc5::BVMinisat namespace */
-} /* cvc5 namespace */
+++ /dev/null
-/****************************************************************************************[System.h]
-Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
-Copyright (c) 2007-2010, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef BVMinisat_System_h
-#define BVMinisat_System_h
-
-#if defined(__linux__)
-#include <fpu_control.h>
-#endif
-
-#include "prop/bvminisat/mtl/IntTypes.h"
-
-//-------------------------------------------------------------------------------------------------
-
-namespace cvc5 {
-namespace BVMinisat {
-
-static inline double cpuTime(void); // CPU-time in seconds.
-extern double memUsed(); // Memory in mega bytes (returns 0 for unsupported architectures).
-extern double memUsedPeak(); // Peak-memory in mega bytes (returns 0 for unsupported architectures).
-
-} // namespace BVMinisat
-} // namespace cvc5
-
-//-------------------------------------------------------------------------------------------------
-// Implementation of inline functions:
-
-#if defined(_MSC_VER) || defined(__MINGW32__)
-#include <time.h>
-
-static inline double cvc5::BVMinisat::cpuTime(void)
-{
- return (double)clock() / CLOCKS_PER_SEC;
-}
-
-#else
-#include <sys/time.h>
-#include <sys/resource.h>
-#include <unistd.h>
-
-static inline double cvc5::BVMinisat::cpuTime(void)
-{
- struct rusage ru;
- getrusage(RUSAGE_SELF, &ru);
- return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000;
-}
-
-#endif
-
-#endif
#include "expr/node.h"
#include "proof/clause_id.h"
#include "proof/proof_node_manager.h"
-#include "prop/bv_sat_solver_notify.h"
#include "prop/sat_solver_types.h"
#include "util/statistics_stats.h"
};/* class SatSolver */
-class BVSatSolverInterface: public SatSolver {
-public:
-
- virtual ~BVSatSolverInterface() {}
- /** Interface for notifications */
-
- virtual void setNotify(BVSatSolverNotify* notify) = 0;
-
- virtual void markUnremovable(SatLiteral lit) = 0;
-
- virtual void getUnsatCore(SatClause& unsatCore) = 0;
-
- virtual void addMarkerLiteral(SatLiteral lit) = 0;
-
- virtual SatValue propagate() = 0;
-
- virtual void explain(SatLiteral lit, std::vector<SatLiteral>& explanation) = 0;
-
- virtual SatValue assertAssumption(SatLiteral lit, bool propagate = false) = 0;
-
- virtual void popAssumption() = 0;
-
-};/* class BVSatSolverInterface */
-
class CDCLTSatSolverInterface : public SatSolver
{
public:
#include "prop/sat_solver_factory.h"
-#include "prop/bvminisat/bvminisat.h"
#include "prop/cadical.h"
#include "prop/cryptominisat.h"
#include "prop/kissat.h"
namespace cvc5 {
namespace prop {
-BVSatSolverInterface* SatSolverFactory::createMinisat(
- context::Context* mainSatContext,
- StatisticsRegistry& registry,
- const std::string& name)
-{
- return new BVMinisatSatSolver(registry, mainSatContext, name);
-}
-
MinisatSatSolver* SatSolverFactory::createCDCLTMinisat(
StatisticsRegistry& registry)
{
class SatSolverFactory
{
public:
- static BVSatSolverInterface* createMinisat(context::Context* mainSatContext,
- StatisticsRegistry& registry,
- const std::string& name = "");
-
static MinisatSatSolver* createCDCLTMinisat(StatisticsRegistry& registry);
static SatSolver* createCryptoMinisat(StatisticsRegistry& registry,
d_passes["ackermann"]->apply(&assertions);
}
- if (options().bv.bvAbstraction)
- {
- d_passes["bv-abstraction"]->apply(&assertions);
- }
-
Debug("smt") << " assertions : " << assertions.size() << endl;
bool noConflict = true;
}
}
- if (opts.bv.bitvectorAigSimplificationsWasSetByUser)
- {
- Notice() << "SolverEngine: setting bitvectorAig" << std::endl;
- opts.bv.bitvectorAig = true;
- }
- if (opts.bv.bitvectorAlgebraicBudgetWasSetByUser)
- {
- Notice() << "SolverEngine: setting bitvectorAlgebraicSolver" << std::endl;
- opts.bv.bitvectorAlgebraicSolver = true;
- }
-
// if we requiring disabling proofs, disable them now
if (opts.smt.produceProofs)
{
opts.bv.boolToBitvector = options::BoolToBVMode::OFF;
}
- if (!opts.bv.bvEagerExplanationsWasSetByUser
- && logic.isTheoryEnabled(THEORY_ARRAYS)
- && logic.isTheoryEnabled(THEORY_BV))
- {
- Trace("smt") << "enabling eager bit-vector explanations " << std::endl;
- opts.bv.bvEagerExplanations = true;
- }
-
// Turn on arith rewrite equalities only for pure arithmetic
if (!opts.arith.arithRewriteEqWasSetByUser)
{
opts.uf.ufssFairnessMonotone = false;
opts.quantifiers.globalNegate = false;
opts.quantifiers.cegqiNestedQE = false;
- opts.bv.bvAbstraction = false;
opts.arith.arithMLTrick = false;
return false;
opts.quantifiers.globalNegate = false;
}
- if (opts.bv.bitvectorAig)
- {
- reason << "bitblast-aig";
- return true;
- }
-
if (opts.smt.doITESimp)
{
reason << "ITE simp";
logic = log;
logic.lock();
}
- if (opts.bv.bvAbstraction)
- {
- // bv abstraction may require UF
- Notice() << "Enabling UF because bvAbstraction requires it." << std::endl;
- needsUf = true;
- }
- else if (opts.quantifiers.preSkolemQuantNested
- && opts.quantifiers.preSkolemQuantNestedWasSetByUser)
+ if (opts.quantifiers.preSkolemQuantNested
+ && opts.quantifiers.preSkolemQuantNestedWasSetByUser)
{
// if pre-skolem nested is explictly set, then we require UF. If it is
// not explicitly set, it is disabled below if UF is not present.
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Aina Niemetz, Mathias Preiner
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * [[ Add lengthier description here ]]
- * \todo document this file
- */
-#include "theory/bv/abstraction.h"
-
-#include "expr/skolem_manager.h"
-#include "options/bv_options.h"
-#include "printer/printer.h"
-#include "smt/dump.h"
-#include "smt/smt_statistics_registry.h"
-#include "theory/bv/theory_bv_utils.h"
-#include "theory/rewriter.h"
-#include "util/bitvector.h"
-
-using namespace cvc5;
-using namespace cvc5::theory;
-using namespace cvc5::theory::bv;
-using namespace cvc5::context;
-
-using namespace std;
-using namespace cvc5::theory::bv::utils;
-
-bool AbstractionModule::applyAbstraction(const std::vector<Node>& assertions,
- std::vector<Node>& new_assertions)
-{
- Debug("bv-abstraction") << "AbstractionModule::applyAbstraction\n";
-
- TimerStat::CodeTimer abstractionTimer(d_statistics.d_abstractionTime);
-
- TNodeSet seen;
- for (unsigned i = 0; i < assertions.size(); ++i)
- {
- if (assertions[i].getKind() == kind::OR)
- {
- for (unsigned j = 0; j < assertions[i].getNumChildren(); ++j)
- {
- if (!isConjunctionOfAtoms(assertions[i][j], seen))
- {
- continue;
- }
- Node signature = computeSignature(assertions[i][j]);
- storeSignature(signature, assertions[i][j]);
- Debug("bv-abstraction") << " assertion: " << assertions[i][j] << "\n";
- Debug("bv-abstraction") << " signature: " << signature << "\n";
- }
- }
- }
- finalizeSignatures();
-
- for (unsigned i = 0; i < assertions.size(); ++i)
- {
- if (assertions[i].getKind() == kind::OR
- && assertions[i][0].getKind() == kind::AND)
- {
- std::vector<Node> new_children;
- for (unsigned j = 0; j < assertions[i].getNumChildren(); ++j)
- {
- if (hasSignature(assertions[i][j]))
- {
- new_children.push_back(abstractSignatures(assertions[i][j]));
- }
- else
- {
- new_children.push_back(assertions[i][j]);
- }
- }
- new_assertions.push_back(utils::mkOr(new_children));
- }
- else
- {
- // assertions that are not changed
- new_assertions.push_back(assertions[i]);
- }
- }
-
- if (options::skolemizeArguments())
- {
- skolemizeArguments(new_assertions);
- }
-
- // if we are using the eager solver reverse the abstraction
- if (options::bitblastMode() == options::BitblastMode::EAGER)
- {
- if (d_funcToSignature.size() == 0)
- {
- // we did not change anything
- return false;
- }
- NodeNodeMap seen_rev;
- for (unsigned i = 0; i < new_assertions.size(); ++i)
- {
- new_assertions[i] = reverseAbstraction(new_assertions[i], seen_rev);
- }
- // we undo the abstraction functions so the logic is QF_BV still
- return true;
- }
-
- // return true if we have created new function symbols for the problem
- return d_funcToSignature.size() != 0;
-}
-
-bool AbstractionModule::isConjunctionOfAtoms(TNode node, TNodeSet& seen)
-{
- if (seen.find(node)!= seen.end())
- return true;
-
- if (!node.getType().isBitVector() && node.getKind() != kind::AND)
- {
- return utils::isBVPredicate(node);
- }
-
- if (node.getNumChildren() == 0)
- return true;
-
- for (unsigned i = 0; i < node.getNumChildren(); ++i) {
- if (!isConjunctionOfAtoms(node[i], seen))
- {
- return false;
- }
- }
- seen.insert(node);
- return true;
-}
-
-
-Node AbstractionModule::reverseAbstraction(Node assertion, NodeNodeMap& seen) {
-
- if (seen.find(assertion) != seen.end())
- return seen[assertion];
-
- if (isAbstraction(assertion)) {
- Node interp = getInterpretation(assertion);
- seen[assertion] = interp;
- Assert(interp.getType() == assertion.getType());
- return interp;
- }
-
- if (assertion.getNumChildren() == 0) {
- seen[assertion] = assertion;
- return assertion;
- }
-
- NodeBuilder result(assertion.getKind());
- if (assertion.getMetaKind() == kind::metakind::PARAMETERIZED) {
- result << assertion.getOperator();
- }
-
- for (unsigned i = 0; i < assertion.getNumChildren(); ++i) {
- result << reverseAbstraction(assertion[i], seen);
- }
- Node res = result;
- seen[assertion] = res;
- return res;
-}
-
-void AbstractionModule::skolemizeArguments(std::vector<Node>& assertions)
-{
- NodeManager* nm = NodeManager::currentNM();
- for (unsigned i = 0; i < assertions.size(); ++i)
- {
- TNode assertion = assertions[i];
- if (assertion.getKind() != kind::OR) continue;
-
- bool is_skolemizable = true;
- for (unsigned k = 0; k < assertion.getNumChildren(); ++k)
- {
- if (assertion[k].getKind() != kind::EQUAL
- || assertion[k][0].getKind() != kind::APPLY_UF
- || assertion[k][1].getKind() != kind::CONST_BITVECTOR
- || assertion[k][1].getConst<BitVector>() != BitVector(1, 1u))
- {
- is_skolemizable = false;
- break;
- }
- }
-
- if (!is_skolemizable) continue;
-
- ArgsTable assertion_table;
-
- // collect function symbols and their arguments
- for (unsigned j = 0; j < assertion.getNumChildren(); ++j)
- {
- TNode current = assertion[j];
- Assert(current.getKind() == kind::EQUAL
- && current[0].getKind() == kind::APPLY_UF);
- TNode func = current[0];
- ArgsVec args;
- for (unsigned k = 0; k < func.getNumChildren(); ++k)
- {
- args.push_back(func[k]);
- }
- assertion_table.addEntry(func.getOperator(), args);
- }
-
- NodeBuilder assertion_builder(kind::OR);
- // construct skolemized assertion
- for (ArgsTable::iterator it = assertion_table.begin();
- it != assertion_table.end();
- ++it)
- {
- // for each function symbol
- ++(d_statistics.d_numArgsSkolemized);
- TNode func = it->first;
- ArgsTableEntry& args = it->second;
- NodeBuilder skolem_func(kind::APPLY_UF);
- skolem_func << func;
- std::vector<Node> skolem_args;
-
- for (unsigned j = 0; j < args.getArity(); ++j)
- {
- bool all_same = true;
- for (unsigned k = 1; k < args.getNumEntries(); ++k)
- {
- if (args.getEntry(k)[j] != args.getEntry(0)[j]) all_same = false;
- }
- Node new_arg = all_same
- ? (Node)args.getEntry(0)[j]
- : utils::mkVar(utils::getSize(args.getEntry(0)[j]));
- skolem_args.push_back(new_arg);
- skolem_func << new_arg;
- }
-
- Node skolem_func_eq1 =
- nm->mkNode(kind::EQUAL, (Node)skolem_func, utils::mkConst(1, 1u));
-
- // enumerate arguments assignments
- std::vector<Node> or_assignments;
- for (const ArgsVec& av : args)
- // for (ArgsTableEntry::iterator it = args.begin(); it != args.end();
- // ++it)
- {
- NodeBuilder arg_assignment(kind::AND);
- // ArgsVec& args = *it;
- for (unsigned k = 0; k < av.size(); ++k)
- {
- Node eq = nm->mkNode(kind::EQUAL, av[k], skolem_args[k]);
- arg_assignment << eq;
- }
- or_assignments.push_back(arg_assignment);
- }
-
- Node new_func_def =
- utils::mkAnd(skolem_func_eq1, utils::mkOr(or_assignments));
- assertion_builder << new_func_def;
- }
- Node new_assertion = assertion_builder;
- Debug("bv-abstraction-dbg") << "AbstractionModule::skolemizeArguments "
- << assertions[i] << " => \n";
- Debug("bv-abstraction-dbg") << " " << new_assertion;
- assertions[i] = new_assertion;
- }
-}
-
-void AbstractionModule::storeSignature(Node signature, TNode assertion) {
- if(d_signatures.find(signature) == d_signatures.end()) {
- d_signatures[signature] = 0;
- }
- d_signatures[signature] = d_signatures[signature] + 1;
- d_assertionToSignature[assertion] = signature;
-}
-
-Node AbstractionModule::computeSignature(TNode node) {
- resetSignatureIndex();
- NodeNodeMap cache;
- Node sig = computeSignatureRec(node, cache);
- return sig;
-}
-
-Node AbstractionModule::getSignatureSkolem(TNode node)
-{
- Assert(node.getMetaKind() == kind::metakind::VARIABLE);
- NodeManager* nm = NodeManager::currentNM();
- SkolemManager* sm = nm->getSkolemManager();
- unsigned bitwidth = utils::getSize(node);
- if (d_signatureSkolems.find(bitwidth) == d_signatureSkolems.end())
- {
- d_signatureSkolems[bitwidth] = vector<Node>();
- }
-
- vector<Node>& skolems = d_signatureSkolems[bitwidth];
- // get the index of bv variables of this size
- unsigned index = getBitwidthIndex(bitwidth);
- Assert(skolems.size() + 1 >= index);
- if (skolems.size() == index)
- {
- ostringstream os;
- os << "sig_" << bitwidth << "_" << index;
- skolems.push_back(sm->mkDummySkolem(os.str(),
- nm->mkBitVectorType(bitwidth),
- "skolem for computing signatures"));
- }
- ++(d_signatureIndices[bitwidth]);
- return skolems[index];
-}
-
-unsigned AbstractionModule::getBitwidthIndex(unsigned bitwidth) {
- if (d_signatureIndices.find(bitwidth) == d_signatureIndices.end()) {
- d_signatureIndices[bitwidth] = 0;
- }
- return d_signatureIndices[bitwidth];
-}
-
-void AbstractionModule::resetSignatureIndex() {
- for (IndexMap::iterator it = d_signatureIndices.begin(); it != d_signatureIndices.end(); ++it) {
- it->second = 0;
- }
-}
-
-bool AbstractionModule::hasSignature(Node node) {
- return d_assertionToSignature.find(node) != d_assertionToSignature.end();
-}
-
-Node AbstractionModule::getGeneralizedSignature(Node node) {
- NodeNodeMap::const_iterator it = d_assertionToSignature.find(node);
- Assert(it != d_assertionToSignature.end());
- Node generalized_signature = getGeneralization(it->second);
- return generalized_signature;
-}
-
-Node AbstractionModule::computeSignatureRec(TNode node, NodeNodeMap& cache) {
- if (cache.find(node) != cache.end()) {
- return cache.find(node)->second;
- }
-
- if (node.getNumChildren() == 0) {
- if (node.getKind() == kind::CONST_BITVECTOR)
- return node;
-
- Node sig = getSignatureSkolem(node);
- cache[node] = sig;
- return sig;
- }
-
- NodeBuilder builder(node.getKind());
- if (node.getMetaKind() == kind::metakind::PARAMETERIZED) {
- builder << node.getOperator();
- }
- for (unsigned i = 0; i < node.getNumChildren(); ++i) {
- Node converted = computeSignatureRec(node[i], cache);
- builder << converted;
- }
- Node result = builder;
- cache[node] = result;
- return result;
-}
-
-/**
- * Returns 0, if the two are equal,
- * 1 if s is a generalization of t
- * 2 if t is a generalization of s
- * -1 if the two cannot be unified
- *
- * @param s
- * @param t
- *
- * @return
- */
-int AbstractionModule::comparePatterns(TNode s, TNode t) {
- if (s.getKind() == kind::SKOLEM &&
- t.getKind() == kind::SKOLEM) {
- return 0;
- }
-
- if (s.getKind() == kind::CONST_BITVECTOR &&
- t.getKind() == kind::CONST_BITVECTOR) {
- if (s == t) {
- return 0;
- } else {
- return -1;
- }
- }
-
- if (s.getKind() == kind::SKOLEM &&
- t.getKind() == kind::CONST_BITVECTOR) {
- return 1;
- }
-
- if (s.getKind() == kind::CONST_BITVECTOR &&
- t.getKind() == kind::SKOLEM) {
- return 2;
- }
-
- if (s.getNumChildren() != t.getNumChildren() ||
- s.getKind() != t.getKind())
- return -1;
-
- int unify = 0;
- for (unsigned i = 0; i < s.getNumChildren(); ++i) {
- int unify_i = comparePatterns(s[i], t[i]);
- if (unify_i < 0)
- return -1;
- if (unify == 0) {
- unify = unify_i;
- } else if (unify != unify_i && unify_i != 0) {
- return -1;
- }
- }
- return unify;
-}
-
-TNode AbstractionModule::getGeneralization(TNode term) {
- NodeNodeMap::iterator it = d_sigToGeneralization.find(term);
- // if not in the map we add it
- if (it == d_sigToGeneralization.end()) {
- d_sigToGeneralization[term] = term;
- return term;
- }
- // doesn't have a generalization
- if (it->second == term)
- return term;
-
- TNode generalization = getGeneralization(it->second);
- Assert(generalization != term);
- d_sigToGeneralization[term] = generalization;
- return generalization;
-}
-
-void AbstractionModule::storeGeneralization(TNode s, TNode t) {
- Assert(s == getGeneralization(s));
- Assert(t == getGeneralization(t));
- d_sigToGeneralization[s] = t;
-}
-
-void AbstractionModule::finalizeSignatures()
-{
- NodeManager* nm = NodeManager::currentNM();
- SkolemManager* sm = nm->getSkolemManager();
- Debug("bv-abstraction")
- << "AbstractionModule::finalizeSignatures num signatures = "
- << d_signatures.size() << "\n";
- TNodeSet new_signatures;
-
- // "unify" signatures
- for (SignatureMap::const_iterator ss = d_signatures.begin();
- ss != d_signatures.end();
- ++ss)
- {
- for (SignatureMap::const_iterator tt = ss; tt != d_signatures.end(); ++tt)
- {
- TNode t = getGeneralization(tt->first);
- TNode s = getGeneralization(ss->first);
-
- if (t != s)
- {
- int status = comparePatterns(s, t);
- Assert(status);
- if (status < 0) continue;
- if (status == 1)
- {
- storeGeneralization(t, s);
- }
- else
- {
- storeGeneralization(s, t);
- }
- }
- }
- }
- // keep only most general signatures
- for (SignatureMap::iterator it = d_signatures.begin();
- it != d_signatures.end();)
- {
- TNode sig = it->first;
- TNode gen = getGeneralization(sig);
- if (sig != gen)
- {
- Assert(d_signatures.find(gen) != d_signatures.end());
- // update the count
- d_signatures[gen] += d_signatures[sig];
- d_signatures.erase(it++);
- }
- else
- {
- ++it;
- }
- }
-
- // remove signatures that are not frequent enough
- for (SignatureMap::iterator it = d_signatures.begin();
- it != d_signatures.end();)
- {
- if (it->second <= 7)
- {
- d_signatures.erase(it++);
- }
- else
- {
- ++it;
- }
- }
-
- for (SignatureMap::const_iterator it = d_signatures.begin();
- it != d_signatures.end();
- ++it)
- {
- TNode signature = it->first;
- // we already processed this signature
- Assert(d_signatureToFunc.find(signature) == d_signatureToFunc.end());
-
- Debug("bv-abstraction") << "Processing signature " << signature << " count "
- << it->second << "\n";
- std::vector<TypeNode> arg_types;
- TNodeSet seen;
- collectArgumentTypes(signature, arg_types, seen);
- Assert(signature.getType().isBoolean());
- // make function return a bitvector of size 1
- // Node bv_function = nm->mkNode(kind::ITE, signature, utils::mkConst(1,
- // 1u), utils::mkConst(1, 0u));
- TypeNode range = nm->mkBitVectorType(1);
-
- TypeNode abs_type = nm->mkFunctionType(arg_types, range);
- Node abs_func = sm->mkDummySkolem(
- "abs_$$", abs_type, "abstraction function for bv theory");
- Debug("bv-abstraction") << " abstracted by function " << abs_func << "\n";
-
- // NOTE: signature expression type is BOOLEAN
- d_signatureToFunc[signature] = abs_func;
- d_funcToSignature[abs_func] = signature;
- }
-
- Debug("bv-abstraction") << "AbstractionModule::finalizeSignatures abstracted "
- << d_signatureToFunc.size() << " signatures. \n";
-}
-
-void AbstractionModule::collectArgumentTypes(TNode sig, std::vector<TypeNode>& types, TNodeSet& seen) {
- if (seen.find(sig) != seen.end())
- return;
-
- if (sig.getKind() == kind::SKOLEM) {
- types.push_back(sig.getType());
- seen.insert(sig);
- return;
- }
-
- for (unsigned i = 0; i < sig.getNumChildren(); ++i) {
- collectArgumentTypes(sig[i], types, seen);
- seen.insert(sig);
- }
-}
-
-void AbstractionModule::collectArguments(TNode node, TNode signature, std::vector<Node>& args, TNodeSet& seen) {
- if (seen.find(node)!= seen.end())
- return;
-
- if (node.getMetaKind() == kind::metakind::VARIABLE
- || node.getKind() == kind::CONST_BITVECTOR)
- {
- // a constant in the node can either map to an argument of the abstraction
- // or can be hard-coded and part of the abstraction
- if (signature.getKind() == kind::SKOLEM) {
- args.push_back(node);
- seen.insert(node);
- } else {
- Assert(signature.getKind() == kind::CONST_BITVECTOR);
- }
- //
- return;
- }
- Assert(node.getKind() == signature.getKind()
- && node.getNumChildren() == signature.getNumChildren());
-
- for (unsigned i = 0; i < node.getNumChildren(); ++i) {
- collectArguments(node[i], signature[i], args, seen);
- seen.insert(node);
- }
-}
-
-Node AbstractionModule::abstractSignatures(TNode assertion)
-{
- Debug("bv-abstraction") << "AbstractionModule::abstractSignatures "
- << assertion << "\n";
- NodeManager* nm = NodeManager::currentNM();
- // assume the assertion has been fully abstracted
- Node signature = getGeneralizedSignature(assertion);
-
- Debug("bv-abstraction") << " with sig " << signature << "\n";
- NodeNodeMap::iterator it = d_signatureToFunc.find(signature);
- if (it != d_signatureToFunc.end())
- {
- std::vector<Node> args;
- TNode func = it->second;
- // pushing the function symbol
- args.push_back(func);
- TNodeSet seen;
- collectArguments(assertion, signature, args, seen);
- std::vector<TNode> real_args;
- for (unsigned i = 1; i < args.size(); ++i)
- {
- real_args.push_back(args[i]);
- }
- d_argsTable.addEntry(func, real_args);
- Node result = nm->mkNode(
- kind::EQUAL,
- nm->mkNode(kind::APPLY_UF, args), utils::mkConst(1, 1u));
- Debug("bv-abstraction") << "=> " << result << "\n";
- Assert(result.getType() == assertion.getType());
- return result;
- }
- return assertion;
-}
-
-bool AbstractionModule::isAbstraction(TNode node) {
- if (node.getKind() != kind::EQUAL)
- return false;
- if ((node[0].getKind() != kind::CONST_BITVECTOR ||
- node[1].getKind() != kind::APPLY_UF) &&
- (node[1].getKind() != kind::CONST_BITVECTOR ||
- node[0].getKind() != kind::APPLY_UF))
- return false;
-
- TNode constant = node[0].getKind() == kind::CONST_BITVECTOR ? node[0] : node[1];
- TNode func = node[0].getKind() == kind::APPLY_UF ? node[0] : node[1];
- Assert(constant.getKind() == kind::CONST_BITVECTOR
- && func.getKind() == kind::APPLY_UF);
- if (utils::getSize(constant) != 1)
- return false;
- if (constant != utils::mkConst(1, 1u))
- return false;
-
- TNode func_symbol = func.getOperator();
- if (d_funcToSignature.find(func_symbol) == d_funcToSignature.end())
- return false;
-
- return true;
-}
-
-Node AbstractionModule::getInterpretation(TNode node) {
- Assert(isAbstraction(node));
- TNode constant = node[0].getKind() == kind::CONST_BITVECTOR ? node[0] : node[1];
- TNode apply = node[0].getKind() == kind::APPLY_UF ? node[0] : node[1];
- Assert(constant.getKind() == kind::CONST_BITVECTOR
- && apply.getKind() == kind::APPLY_UF);
-
- Node func = apply.getOperator();
- Assert(d_funcToSignature.find(func) != d_funcToSignature.end());
-
- Node sig = d_funcToSignature[func];
-
- // substitute arguments in signature
- TNodeTNodeMap seen;
- unsigned index = 0;
- Node result = substituteArguments(sig, apply, index, seen);
- Assert(result.getType().isBoolean());
- Assert(index == apply.getNumChildren());
- // Debug("bv-abstraction") << "AbstractionModule::getInterpretation " << node << "\n";
- // Debug("bv-abstraction") << " => " << result << "\n";
- return result;
-}
-
-Node AbstractionModule::substituteArguments(TNode signature, TNode apply, unsigned& index, TNodeTNodeMap& seen) {
- if (seen.find(signature) != seen.end()) {
- return seen[signature];
- }
-
- if (signature.getKind() == kind::SKOLEM) {
- // return corresponding argument and increment counter
- seen[signature] = apply[index];
- return apply[index++];
- }
-
- if (signature.getNumChildren() == 0) {
- Assert(signature.getMetaKind() != kind::metakind::VARIABLE);
- seen[signature] = signature;
- return signature;
- }
-
- NodeBuilder builder(signature.getKind());
- if (signature.getMetaKind() == kind::metakind::PARAMETERIZED) {
- builder << signature.getOperator();
- }
-
- for (unsigned i = 0; i < signature.getNumChildren(); ++i) {
- Node child = substituteArguments(signature[i], apply, index, seen);
- builder << child;
- }
-
- Node result = builder;
- seen[signature]= result;
-
- return result;
-}
-
-Node AbstractionModule::simplifyConflict(TNode conflict) {
- Debug("bv-abstraction-dbg") << "AbstractionModule::simplifyConflict " << conflict << "\n";
- if (conflict.getKind() != kind::AND)
- return conflict;
-
- std::vector<Node> conjuncts;
- for (unsigned i = 0; i < conflict.getNumChildren(); ++i)
- conjuncts.push_back(conflict[i]);
-
- theory::SubstitutionMap subst(new context::Context());
- for (unsigned i = 0; i < conjuncts.size(); ++i) {
- TNode conjunct = conjuncts[i];
- // substitute s -> t
- Node s, t;
-
- if (conjunct.getKind() == kind::EQUAL) {
- if (conjunct[0].getMetaKind() == kind::metakind::VARIABLE &&
- conjunct[1].getKind() == kind::CONST_BITVECTOR) {
- s = conjunct[0];
- t = conjunct[1];
- }
- else if (conjunct[1].getMetaKind() == kind::metakind::VARIABLE &&
- conjunct[0].getKind() == kind::CONST_BITVECTOR) {
- s = conjunct[1];
- t = conjunct[0];
- } else {
- continue;
- }
-
- Assert(!subst.hasSubstitution(s));
- Assert(!t.isNull() && !s.isNull() && s != t);
- subst.addSubstitution(s, t);
-
- for (unsigned k = 0; k < conjuncts.size(); k++) {
- conjuncts[k] = subst.apply(conjuncts[k]);
- }
- }
- }
- Node new_conflict = Rewriter::rewrite(utils::mkAnd(conjuncts));
-
- Debug("bv-abstraction") << "AbstractionModule::simplifyConflict conflict " << conflict <<"\n";
- Debug("bv-abstraction") << " => " << new_conflict <<"\n";
-
- return new_conflict;
-}
-
-void DebugPrintInstantiations(
- const std::vector<std::vector<ArgsVec> >& instantiations,
- const std::vector<TNode>& functions)
-{
- // print header
- Debug("bv-abstraction-dbg") <<"[ ";
- for (unsigned i = 0; i < functions.size(); ++i) {
- for (unsigned j = 1; j < functions[i].getNumChildren(); ++j) {
- Debug("bv-abstraction-dgb") << functions[i][j] <<" ";
- }
- Debug("bv-abstraction-dgb") << " || ";
- }
- Debug("bv-abstraction-dbg") <<"]\n";
-
- for (unsigned i = 0; i < instantiations.size(); ++i) {
- Debug("bv-abstraction-dbg") <<"[";
- const std::vector<ArgsVec>& inst = instantiations[i];
- for (unsigned j = 0; j < inst.size(); ++j) {
- for (unsigned k = 0; k < inst[j].size(); ++k) {
- Debug("bv-abstraction-dbg") << inst[j][k] << " ";
- }
- Debug("bv-abstraction-dbg") << " || ";
- }
- Debug("bv-abstraction-dbg") <<"]\n";
- }
-}
-
-void AbstractionModule::generalizeConflict(TNode conflict, std::vector<Node>& lemmas) {
- Debug("bv-abstraction") << "AbstractionModule::generalizeConflict " << conflict << "\n";
- std::vector<TNode> functions;
-
- // collect abstract functions
- if (conflict.getKind() != kind::AND) {
- if (isAbstraction(conflict)) {
- Assert(conflict[0].getKind() == kind::APPLY_UF);
- functions.push_back(conflict[0]);
- }
- } else {
- for (unsigned i = 0; i < conflict.getNumChildren(); ++i) {
- TNode conjunct = conflict[i];
- if (isAbstraction(conjunct)) {
- Assert(conjunct[0].getKind() == kind::APPLY_UF);
- functions.push_back(conjunct[0]);
- }
- }
- }
-
- // if (functions.size() >= 3) {
- // // dump conflict
- // NodeNodeMap seen;
- // Node reversed = reverseAbstraction(conflict, seen);
- // std::cout << "CONFLICT " << reversed << "\n";
- // }
-
-
- if (functions.size() == 0 || functions.size() > options::bvNumFunc()) {
- return;
- }
-
-
- // Skolemize function arguments to avoid confusion in pattern matching
- SubstitutionMap skolem_subst(new context::Context());
- SubstitutionMap reverse_skolem(new context::Context());
- makeFreshSkolems(conflict, skolem_subst, reverse_skolem);
-
- Node skolemized_conflict = skolem_subst.apply(conflict);
- for (unsigned i = 0; i < functions.size(); ++i) {
- functions[i] = skolem_subst.apply(functions[i]);
- }
-
- conflict = skolem_subst.apply(conflict);
-
- LemmaInstantiatior inst(functions, d_argsTable, conflict);
- std::vector<Node> new_lemmas;
- inst.generateInstantiations(new_lemmas);
- for (unsigned i = 0; i < new_lemmas.size(); ++i) {
- TNode lemma = reverse_skolem.apply(new_lemmas[i]);
- if (d_addedLemmas.find(lemma) == d_addedLemmas.end()) {
- lemmas.push_back(lemma);
- Debug("bv-abstraction-gen") << "adding lemma " << lemma << "\n";
- storeLemma(lemma);
- }
- }
-}
-
-int AbstractionModule::LemmaInstantiatior::next(int val, int index) {
- if (val < d_maxMatch[index] - 1)
- return val + 1;
- return -1;
-}
-
-/**
- * Assumes the stack without top is consistent, and checks that the
- * full stack is consistent
- *
- * @param stack
- *
- * @return
- */
-bool AbstractionModule::LemmaInstantiatior::isConsistent(const vector<int>& stack) {
- if (stack.empty())
- return true;
-
- unsigned current = stack.size() - 1;
- TNode func = d_functions[current];
- ArgsTableEntry& matches = d_argsTable.getEntry(func.getOperator());
- ArgsVec& args = matches.getEntry(stack[current]);
- Assert(args.size() == func.getNumChildren());
- for (unsigned k = 0; k < args.size(); ++k) {
- TNode s = func[k];
- TNode t = args[k];
-
- TNode s0 = s;
- while (d_subst.hasSubstitution(s0)) {
- s0 = d_subst.getSubstitution(s0);
- }
-
- TNode t0 = t;
- while (d_subst.hasSubstitution(t0)) {
- t0 = d_subst.getSubstitution(t0);
- }
-
- if (s0.isConst() && t0.isConst()) {
- if (s0 != t0)
- return false; // fail
- else
- continue;
- }
-
- if(s0.getMetaKind() == kind::metakind::VARIABLE &&
- t0.isConst()) {
- d_subst.addSubstitution(s0, t0);
- continue;
- }
-
- if (s0.isConst() &&
- t0.getMetaKind() == kind::metakind::VARIABLE) {
- d_subst.addSubstitution(t0, s0);
- continue;
- }
-
- Assert(s0.getMetaKind() == kind::metakind::VARIABLE
- && t0.getMetaKind() == kind::metakind::VARIABLE);
-
- if (s0 != t0) {
- d_subst.addSubstitution(s0, t0);
- }
- }
- return true;
-}
-
-bool AbstractionModule::LemmaInstantiatior::accept(const vector<int>& stack) {
- return stack.size() == d_functions.size();
-}
-
-void AbstractionModule::LemmaInstantiatior::mkLemma() {
- Node lemma = d_subst.apply(d_conflict);
- // Debug("bv-abstraction-gen") << "AbstractionModule::LemmaInstantiatior::mkLemma " << lemma <<"\n";
- d_lemmas.push_back(lemma);
-}
-
-void AbstractionModule::LemmaInstantiatior::backtrack(vector<int>& stack) {
- if (!isConsistent(stack))
- return;
-
- if (accept(stack)) {
- mkLemma();
- return;
- }
-
- int x = 0;
- while (x != -1) {
- d_ctx->push();
- stack.push_back(x);
- backtrack(stack);
-
- d_ctx->pop();
- stack.pop_back();
- x = next(x, stack.size());
- }
-}
-
-
-void AbstractionModule::LemmaInstantiatior::generateInstantiations(std::vector<Node>& lemmas) {
- Debug("bv-abstraction-gen") << "AbstractionModule::LemmaInstantiatior::generateInstantiations ";
-
- std::vector<int> stack;
- backtrack(stack);
- Assert(d_ctx->getLevel() == 0);
- Debug("bv-abstraction-gen") << "numLemmas=" << d_lemmas.size() <<"\n";
- lemmas.swap(d_lemmas);
-}
-
-void AbstractionModule::makeFreshSkolems(TNode node, SubstitutionMap& map, SubstitutionMap& reverse_map) {
- if (map.hasSubstitution(node)) {
- return;
- }
- if (node.getMetaKind() == kind::metakind::VARIABLE) {
- Node skolem = utils::mkVar(utils::getSize(node));
- map.addSubstitution(node, skolem);
- reverse_map.addSubstitution(skolem, node);
- return;
- }
- if (node.isConst())
- return;
-
- for (unsigned i = 0; i < node.getNumChildren(); ++i) {
- makeFreshSkolems(node[i], map, reverse_map);
- }
-}
-
-void AbstractionModule::makeFreshArgs(TNode func, std::vector<Node>& fresh_args) {
- Assert(fresh_args.size() == 0);
- Assert(func.getKind() == kind::APPLY_UF);
- TNodeNodeMap d_map;
- for (unsigned i = 0; i < func.getNumChildren(); ++i) {
- TNode arg = func[i];
- if (arg.isConst()) {
- fresh_args.push_back(arg);
- continue;
- }
- Assert(arg.getMetaKind() == kind::metakind::VARIABLE);
- TNodeNodeMap::iterator it = d_map.find(arg);
- if (it != d_map.end()) {
- fresh_args.push_back(it->second);
- } else {
- Node skolem = utils::mkVar(utils::getSize(arg));
- d_map[arg] = skolem;
- fresh_args.push_back(skolem);
- }
- }
- Assert(fresh_args.size() == func.getNumChildren());
-}
-
-Node AbstractionModule::tryMatching(const std::vector<Node>& ss, const std::vector<TNode>& tt, TNode conflict) {
- Assert(ss.size() == tt.size());
-
- Debug("bv-abstraction-dbg") << "AbstractionModule::tryMatching conflict = " << conflict << "\n";
- if (Debug.isOn("bv-abstraction-dbg")) {
- Debug("bv-abstraction-dbg") << " Match: ";
- for (unsigned i = 0; i < ss.size(); ++i) {
- Debug("bv-abstraction-dbg") << ss[i] <<" ";
-
- }
- Debug("bv-abstraction-dbg") << "\n To: ";
- for (unsigned i = 0; i < tt.size(); ++i) {
- Debug("bv-abstraction-dbg") << tt[i] <<" ";
- }
- Debug("bv-abstraction-dbg") <<"\n";
- }
-
-
- SubstitutionMap subst(new context::Context());
-
- for (unsigned i = 0; i < ss.size(); ++i) {
- TNode s = ss[i];
- TNode t = tt[i];
-
- TNode s0 = subst.hasSubstitution(s) ? subst.getSubstitution(s) : s;
- TNode t0 = subst.hasSubstitution(t) ? subst.getSubstitution(t) : t;
-
- if (s0.isConst() && t0.isConst()) {
- if (s0 != t0)
- return Node(); // fail
- else
- continue;
- }
-
- if(s0.getMetaKind() == kind::metakind::VARIABLE &&
- t0.isConst()) {
- subst.addSubstitution(s0, t0);
- continue;
- }
-
- if (s0.isConst() &&
- t0.getMetaKind() == kind::metakind::VARIABLE) {
- subst.addSubstitution(t0, s0);
- continue;
- }
-
- Assert(s0.getMetaKind() == kind::metakind::VARIABLE
- && t0.getMetaKind() == kind::metakind::VARIABLE);
-
- Assert(s0 != t0);
- subst.addSubstitution(s0, t0);
- }
-
- Node res = subst.apply(conflict);
- Debug("bv-abstraction-dbg") << " Lemma: " << res <<"\n";
- return res;
-}
-
-void AbstractionModule::storeLemma(TNode lemma) {
- d_addedLemmas.insert(lemma);
- if (lemma.getKind() == kind::AND) {
- for (unsigned i = 0; i < lemma.getNumChildren(); i++) {
- TNode atom = lemma[i];
- atom = atom.getKind() == kind::NOT ? atom[0] : atom;
- Assert(atom.getKind() != kind::NOT);
- Assert(utils::isBVPredicate(atom));
- d_lemmaAtoms.insert(atom);
- }
- } else {
- lemma = lemma.getKind() == kind::NOT? lemma[0] : lemma;
- Assert(utils::isBVPredicate(lemma));
- d_lemmaAtoms.insert(lemma);
- }
-}
-
-
-bool AbstractionModule::isLemmaAtom(TNode node) const {
- Assert(node.getType().isBoolean());
- node = node.getKind() == kind::NOT? node[0] : node;
-
- return d_inputAtoms.find(node) == d_inputAtoms.end() &&
- d_lemmaAtoms.find(node) != d_lemmaAtoms.end();
-}
-
-void AbstractionModule::addInputAtom(TNode atom) {
- if (options::bitblastMode() == options::BitblastMode::LAZY)
- {
- d_inputAtoms.insert(atom);
- }
-}
-
-void AbstractionModule::ArgsTableEntry::addArguments(const ArgsVec& args) {
- Assert(args.size() == d_arity);
- d_data.push_back(args);
-}
-
-void AbstractionModule::ArgsTable::addEntry(TNode signature, const ArgsVec& args) {
- if (d_data.find(signature) == d_data.end()) {
- d_data[signature] = ArgsTableEntry(args.size());
- }
- ArgsTableEntry& entry = d_data[signature];
- entry.addArguments(args);
-}
-
-
-bool AbstractionModule::ArgsTable::hasEntry(TNode signature) const {
- return d_data.find(signature) != d_data.end();
-}
-
-AbstractionModule::ArgsTableEntry& AbstractionModule::ArgsTable::getEntry(TNode signature) {
- Assert(hasEntry(signature));
- return d_data.find(signature)->second;
-}
-
-AbstractionModule::Statistics::Statistics(
- const std::string& name, const NodeNodeMap& functionsAbstracted)
- : d_numFunctionsAbstracted(
- smtStatisticsRegistry().registerSize<NodeNodeMap>(
- name + "NumFunctionsAbstracted", functionsAbstracted)),
- d_numArgsSkolemized(
- smtStatisticsRegistry().registerInt(name + "NumArgsSkolemized")),
- d_abstractionTime(
- smtStatisticsRegistry().registerTimer(name + "AbstractionTime"))
-{
-}
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Tim King, Mathias Preiner
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Bitvector theory.
- */
-
-#include "cvc5_private.h"
-
-#ifndef CVC5__THEORY__BV__ABSTRACTION_H
-#define CVC5__THEORY__BV__ABSTRACTION_H
-
-#include <unordered_map>
-#include <unordered_set>
-
-#include "expr/node.h"
-#include "theory/substitutions.h"
-#include "util/statistics_stats.h"
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-typedef std::vector<TNode> ArgsVec;
-
-class AbstractionModule {
- using NodeVecMap = std::unordered_map<Node, std::vector<Node>>;
- using NodeTNodeMap = std::unordered_map<Node, TNode>;
- using TNodeTNodeMap = std::unordered_map<TNode, TNode>;
- using NodeNodeMap = std::unordered_map<Node, Node>;
- using TNodeNodeMap = std::unordered_map<Node, TNode>;
- using TNodeSet = std::unordered_set<TNode>;
- using IntNodeMap = std::unordered_map<unsigned, Node>;
- using IndexMap = std::unordered_map<unsigned, unsigned>;
- using SkolemMap = std::unordered_map<unsigned, std::vector<Node> >;
- using SignatureMap = std::unordered_map<TNode, unsigned>;
-
- struct Statistics {
- SizeStat<NodeNodeMap> d_numFunctionsAbstracted;
- IntStat d_numArgsSkolemized;
- TimerStat d_abstractionTime;
- Statistics(const std::string& name, const NodeNodeMap& functionsAbstracted);
- };
-
-
- class ArgsTableEntry {
- std::vector<ArgsVec> d_data;
- unsigned d_arity;
- public:
- ArgsTableEntry(unsigned n)
- : d_arity(n)
- {}
- ArgsTableEntry()
- : d_arity(0)
- {}
- void addArguments(const ArgsVec& args);
- typedef std::vector<ArgsVec>::iterator iterator;
-
- iterator begin() { return d_data.begin(); }
- iterator end() { return d_data.end(); }
- unsigned getArity() { return d_arity; }
- unsigned getNumEntries() { return d_data.size(); }
- ArgsVec& getEntry(unsigned i)
- {
- Assert(i < d_data.size());
- return d_data[i];
- }
- };
-
- class ArgsTable {
- std::unordered_map<TNode, ArgsTableEntry> d_data;
- bool hasEntry(TNode signature) const;
- public:
- typedef std::unordered_map<TNode, ArgsTableEntry>::iterator iterator;
- ArgsTable() {}
- void addEntry(TNode signature, const ArgsVec& args);
- ArgsTableEntry& getEntry(TNode signature);
- iterator begin() { return d_data.begin(); }
- iterator end() { return d_data.end(); }
- };
-
- /**
- * Checks if one pattern is a generalization of the other
- *
- * @param s
- * @param t
- *
- * @return 1 if s :> t, 2 if s <: t, 0 if they equivalent and -1 if they are incomparable
- */
- static int comparePatterns(TNode s, TNode t);
-
- class LemmaInstantiatior {
- std::vector<TNode> d_functions;
- std::vector<int> d_maxMatch;
- ArgsTable& d_argsTable;
- context::Context* d_ctx;
- theory::SubstitutionMap d_subst;
- TNode d_conflict;
- std::vector<Node> d_lemmas;
-
- void backtrack(std::vector<int>& stack);
- int next(int val, int index);
- bool isConsistent(const std::vector<int>& stack);
- bool accept(const std::vector<int>& stack);
- void mkLemma();
- public:
- LemmaInstantiatior(const std::vector<TNode>& functions, ArgsTable& table, TNode conflict)
- : d_functions(functions)
- , d_argsTable(table)
- , d_ctx(new context::Context())
- , d_subst(d_ctx)
- , d_conflict(conflict)
- , d_lemmas()
- {
- Debug("bv-abstraction-gen") << "LemmaInstantiator conflict:" << conflict << "\n";
- // initializing the search space
- for (unsigned i = 0; i < functions.size(); ++i) {
- TNode func_op = functions[i].getOperator();
- // number of matches for this function
- unsigned maxCount = table.getEntry(func_op).getNumEntries();
- d_maxMatch.push_back(maxCount);
- }
- }
-
- void generateInstantiations(std::vector<Node>& lemmas);
-
- };
-
- ArgsTable d_argsTable;
-
- // mapping between signature and uninterpreted function symbol used to
- // abstract the signature
- NodeNodeMap d_signatureToFunc;
- NodeNodeMap d_funcToSignature;
-
- NodeNodeMap d_assertionToSignature;
- SignatureMap d_signatures;
- NodeNodeMap d_sigToGeneralization;
- TNodeSet d_skolems;
-
- // skolems maps
- IndexMap d_signatureIndices;
- SkolemMap d_signatureSkolems;
-
- void collectArgumentTypes(TNode sig, std::vector<TypeNode>& types, TNodeSet& seen);
- void collectArguments(TNode node, TNode sig, std::vector<Node>& args, TNodeSet& seen);
- void finalizeSignatures();
- Node abstractSignatures(TNode assertion);
- Node computeSignature(TNode node);
-
- bool isConjunctionOfAtoms(TNode node, TNodeSet& seen);
-
- TNode getGeneralization(TNode term);
- void storeGeneralization(TNode s, TNode t);
-
- // signature skolem stuff
- Node getGeneralizedSignature(Node node);
- Node getSignatureSkolem(TNode node);
-
- unsigned getBitwidthIndex(unsigned bitwidth);
- void resetSignatureIndex();
- Node computeSignatureRec(TNode, NodeNodeMap&);
- void storeSignature(Node signature, TNode assertion);
- bool hasSignature(Node node);
-
- Node substituteArguments(TNode signature, TNode apply, unsigned& i, TNodeTNodeMap& seen);
-
- // crazy instantiation methods
- void generateInstantiations(unsigned current,
- std::vector<ArgsTableEntry>& matches,
- std::vector<std::vector<ArgsVec> >& instantiations,
- std::vector<std::vector<ArgsVec> >& new_instantiations);
-
- Node tryMatching(const std::vector<Node>& ss, const std::vector<TNode>& tt, TNode conflict);
- void makeFreshArgs(TNode func, std::vector<Node>& fresh_args);
- void makeFreshSkolems(TNode node, SubstitutionMap& map, SubstitutionMap& reverse_map);
-
- void skolemizeArguments(std::vector<Node>& assertions);
- Node reverseAbstraction(Node assertion, NodeNodeMap& seen);
-
- TNodeSet d_addedLemmas;
- TNodeSet d_lemmaAtoms;
- TNodeSet d_inputAtoms;
- void storeLemma(TNode lemma);
-
- Statistics d_statistics;
-
-public:
- AbstractionModule(const std::string& name)
- : d_argsTable(),
- d_signatureToFunc(),
- d_funcToSignature(),
- d_assertionToSignature(),
- d_signatures(),
- d_sigToGeneralization(),
- d_skolems(),
- d_signatureIndices(),
- d_signatureSkolems(),
- d_addedLemmas(),
- d_lemmaAtoms(),
- d_inputAtoms(),
- d_statistics(name + "abstraction::", d_signatureToFunc)
- {
- }
- /**
- * returns true if there are new uninterepreted functions symbols in the output
- *
- * @param assertions
- * @param new_assertions
- *
- * @return
- */
- bool applyAbstraction(const std::vector<Node>& assertions, std::vector<Node>& new_assertions);
- /**
- * Returns true if the node represents an abstraction predicate.
- *
- * @param node
- *
- * @return
- */
- bool isAbstraction(TNode node);
- /**
- * Returns the interpretation of the abstraction predicate.
- *
- * @param node
- *
- * @return
- */
- Node getInterpretation(TNode node);
- Node simplifyConflict(TNode conflict);
- void generalizeConflict(TNode conflict, std::vector<Node>& lemmas);
- void addInputAtom(TNode atom);
- bool isLemmaAtom(TNode node) const;
-};
-
-}
-}
-} // namespace cvc5
-
-#endif
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Mathias Preiner, Tim King
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * AIG bitblaster.
- */
-
-#include "theory/bv/bitblast/aig_bitblaster.h"
-
-#include "base/check.h"
-#include "cvc5_private.h"
-#include "options/bv_options.h"
-#include "prop/cnf_stream.h"
-#include "prop/sat_solver.h"
-#include "prop/sat_solver_factory.h"
-#include "smt/smt_statistics_registry.h"
-
-#ifdef CVC5_USE_ABC
-
-extern "C" {
-#include "base/abc/abc.h"
-#include "base/main/main.h"
-#include "sat/cnf/cnf.h"
-
-extern Aig_Man_t* Abc_NtkToDar(Abc_Ntk_t* pNtk, int fExors, int fRegisters);
-}
-
-// Function is defined as static in ABC. Not sure how else to do this.
-static inline int Cnf_Lit2Var(int Lit)
-{
- return (Lit & 1) ? -(Lit >> 1) - 1 : (Lit >> 1) + 1;
-}
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-template <> inline
-std::string toString<Abc_Obj_t*> (const std::vector<Abc_Obj_t*>& bits) {
- Unreachable() << "Don't know how to print AIG";
-}
-
-
-template <> inline
-Abc_Obj_t* mkTrue<Abc_Obj_t*>() {
- return Abc_AigConst1(AigBitblaster::currentAigNtk());
-}
-
-template <> inline
-Abc_Obj_t* mkFalse<Abc_Obj_t*>() {
- return Abc_ObjNot(mkTrue<Abc_Obj_t*>());
-}
-
-template <> inline
-Abc_Obj_t* mkNot<Abc_Obj_t*>(Abc_Obj_t* a) {
- return Abc_ObjNot(a);
-}
-
-template <> inline
-Abc_Obj_t* mkOr<Abc_Obj_t*>(Abc_Obj_t* a, Abc_Obj_t* b) {
- return Abc_AigOr(AigBitblaster::currentAigM(), a, b);
-}
-
-template <> inline
-Abc_Obj_t* mkOr<Abc_Obj_t*>(const std::vector<Abc_Obj_t*>& children) {
- Assert(children.size());
- if (children.size() == 1)
- return children[0];
-
- Abc_Obj_t* result = children[0];
- for (unsigned i = 1; i < children.size(); ++i) {
- result = Abc_AigOr(AigBitblaster::currentAigM(), result, children[i]);
- }
- return result;
-}
-
-
-template <> inline
-Abc_Obj_t* mkAnd<Abc_Obj_t*>(Abc_Obj_t* a, Abc_Obj_t* b) {
- return Abc_AigAnd(AigBitblaster::currentAigM(), a, b);
-}
-
-template <> inline
-Abc_Obj_t* mkAnd<Abc_Obj_t*>(const std::vector<Abc_Obj_t*>& children) {
- Assert(children.size());
- if (children.size() == 1)
- return children[0];
-
- Abc_Obj_t* result = children[0];
- for (unsigned i = 1; i < children.size(); ++i) {
- result = Abc_AigAnd(AigBitblaster::currentAigM(), result, children[i]);
- }
- return result;
-}
-
-template <> inline
-Abc_Obj_t* mkXor<Abc_Obj_t*>(Abc_Obj_t* a, Abc_Obj_t* b) {
- return Abc_AigXor(AigBitblaster::currentAigM(), a, b);
-}
-
-template <> inline
-Abc_Obj_t* mkIff<Abc_Obj_t*>(Abc_Obj_t* a, Abc_Obj_t* b) {
- return mkNot(mkXor(a, b));
-}
-
-template <> inline
-Abc_Obj_t* mkIte<Abc_Obj_t*>(Abc_Obj_t* cond, Abc_Obj_t* a, Abc_Obj_t* b) {
- return Abc_AigMux(AigBitblaster::currentAigM(), cond, a, b);
-}
-
-thread_local Abc_Ntk_t* AigBitblaster::s_abcAigNetwork = nullptr;
-
-Abc_Ntk_t* AigBitblaster::currentAigNtk() {
- if (!AigBitblaster::s_abcAigNetwork) {
- Abc_Start();
- s_abcAigNetwork = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1);
- char pName[] = "cvc5::theory::bv::AigNetwork";
- s_abcAigNetwork->pName = Extra_UtilStrsav(pName);
- }
-
- return s_abcAigNetwork;
-}
-
-
-Abc_Aig_t* AigBitblaster::currentAigM() {
- return (Abc_Aig_t*)(currentAigNtk()->pManFunc);
-}
-
-AigBitblaster::AigBitblaster()
- : TBitblaster<Abc_Obj_t*>(),
- d_nullContext(new context::Context()),
- d_aigCache(),
- d_bbAtoms(),
- d_aigOutputNode(NULL),
- d_notify()
-{
- prop::SatSolver* solver = nullptr;
- switch (options::bvSatSolver())
- {
- case options::SatSolverMode::MINISAT:
- {
- prop::BVSatSolverInterface* minisat =
- prop::SatSolverFactory::createMinisat(d_nullContext.get(),
- smtStatisticsRegistry(),
- "theory::bv::AigBitblaster::");
- d_notify.reset(new MinisatEmptyNotify());
- minisat->setNotify(d_notify.get());
- solver = minisat;
- break;
- }
- case options::SatSolverMode::CADICAL:
- solver = prop::SatSolverFactory::createCadical(
- smtStatisticsRegistry(), "theory::bv::AigBitblaster::");
- break;
- case options::SatSolverMode::CRYPTOMINISAT:
- solver = prop::SatSolverFactory::createCryptoMinisat(
- smtStatisticsRegistry(), "theory::bv::AigBitblaster::");
- break;
- case options::SatSolverMode::KISSAT:
- solver = prop::SatSolverFactory::createKissat(
- smtStatisticsRegistry(), "theory::bv::AigBitblaster::");
- break;
- default: CVC5_FATAL() << "Unknown SAT solver type";
- }
- d_satSolver.reset(solver);
-}
-
-AigBitblaster::~AigBitblaster() {}
-
-Abc_Obj_t* AigBitblaster::bbFormula(TNode node) {
- Assert(node.getType().isBoolean());
- Debug("bitvector-bitblast") << "AigBitblaster::bbFormula "<< node << "\n";
-
- if (hasAig(node))
- return getAig(node);
-
- Abc_Obj_t* result = NULL;
-
- Debug("bitvector-aig") << "AigBitblaster::convertToAig " << node <<"\n";
- switch (node.getKind()) {
- case kind::AND:
- {
- result = bbFormula(node[0]);
- for (unsigned i = 1; i < node.getNumChildren(); ++i) {
- Abc_Obj_t* child = bbFormula(node[i]);
- result = mkAnd(result, child);
- }
- break;
- }
- case kind::OR:
- {
- result = bbFormula(node[0]);
- for (unsigned i = 1; i < node.getNumChildren(); ++i) {
- Abc_Obj_t* child = bbFormula(node[i]);
- result = mkOr(result, child);
- }
- break;
- }
- case kind::XOR:
- {
- result = bbFormula(node[0]);
- for (unsigned i = 1; i < node.getNumChildren(); ++i) {
- Abc_Obj_t* child = bbFormula(node[i]);
- result = mkXor(result, child);
- }
- break;
- }
- case kind::IMPLIES:
- {
- Assert(node.getNumChildren() == 2);
- Abc_Obj_t* child1 = bbFormula(node[0]);
- Abc_Obj_t* child2 = bbFormula(node[1]);
-
- result = mkOr(mkNot(child1), child2);
- break;
- }
- case kind::ITE:
- {
- Assert(node.getNumChildren() == 3);
- Abc_Obj_t* a = bbFormula(node[0]);
- Abc_Obj_t* b = bbFormula(node[1]);
- Abc_Obj_t* c = bbFormula(node[2]);
- result = mkIte(a, b, c);
- break;
- }
- case kind::NOT:
- {
- Abc_Obj_t* child1 = bbFormula(node[0]);
- result = mkNot(child1);
- break;
- }
- case kind::CONST_BOOLEAN:
- {
- result = node.getConst<bool>() ? mkTrue<Abc_Obj_t*>() : mkFalse<Abc_Obj_t*>();
- break;
- }
- case kind::EQUAL:
- {
- if( node[0].getType().isBoolean() ){
- Assert(node.getNumChildren() == 2);
- Abc_Obj_t* child1 = bbFormula(node[0]);
- Abc_Obj_t* child2 = bbFormula(node[1]);
-
- result = mkIff(child1, child2);
- break;
- }
- //else, continue...
- }
- default:
- if( node.isVar() ){
- result = mkInput(node);
- }else{
- bbAtom(node);
- result = getBBAtom(node);
- }
- }
-
- cacheAig(node, result);
- Debug("bitvector-aig") << "AigBitblaster::bbFormula done " << node << " => " << result <<"\n";
- return result;
-}
-
-void AigBitblaster::bbAtom(TNode node) {
- if (hasBBAtom(node)) {
- return;
- }
-
- Debug("bitvector-bitblast") << "Bitblasting atom " << node <<"\n";
-
- // the bitblasted definition of the atom
- Node normalized = Rewriter::rewrite(node);
- Abc_Obj_t* atom_bb = (d_atomBBStrategies[normalized.getKind()])(normalized, this);
- storeBBAtom(node, atom_bb);
- Debug("bitvector-bitblast") << "Done bitblasting atom " << node <<"\n";
-}
-
-void AigBitblaster::bbTerm(TNode node, Bits& bits) {
- if (hasBBTerm(node)) {
- getBBTerm(node, bits);
- return;
- }
- Assert(node.getType().isBitVector());
-
- Debug("bitvector-bitblast") << "Bitblasting term " << node <<"\n";
- d_termBBStrategies[node.getKind()] (node, bits, this);
-
- Assert(bits.size() == utils::getSize(node));
- storeBBTerm(node, bits);
-}
-
-
-void AigBitblaster::cacheAig(TNode node, Abc_Obj_t* aig) {
- Assert(!hasAig(node));
- d_aigCache.insert(std::make_pair(node, aig));
-}
-bool AigBitblaster::hasAig(TNode node) {
- return d_aigCache.find(node) != d_aigCache.end();
-}
-Abc_Obj_t* AigBitblaster::getAig(TNode node) {
- Assert(hasAig(node));
- Debug("bitvector-aig") << "AigSimplifer::getAig " << node << " => " << d_aigCache.find(node)->second <<"\n";
- return d_aigCache.find(node)->second;
-}
-
-void AigBitblaster::makeVariable(TNode node, Bits& bits) {
-
- for (unsigned i = 0; i < utils::getSize(node); ++i) {
- Node bit = utils::mkBitOf(node, i);
- Abc_Obj_t* input = mkInput(bit);
- cacheAig(bit, input);
- bits.push_back(input);
- }
-}
-
-Abc_Obj_t* AigBitblaster::mkInput(TNode input) {
- Assert(!hasInput(input));
- Assert(input.getKind() == kind::BITVECTOR_BITOF
- || (input.getType().isBoolean() && input.isVar()));
- Abc_Obj_t* aig_input = Abc_NtkCreatePi(currentAigNtk());
- // d_aigCache.insert(std::make_pair(input, aig_input));
- d_nodeToAigInput.insert(std::make_pair(input, aig_input));
- Debug("bitvector-aig") << "AigSimplifer::mkInput " << input << " " << aig_input <<"\n";
- return aig_input;
-}
-
-bool AigBitblaster::hasInput(TNode input) {
- return d_nodeToAigInput.find(input) != d_nodeToAigInput.end();
-}
-
-bool AigBitblaster::solve(TNode node) {
- // setting output of network to be the query
- Assert(d_aigOutputNode == NULL);
- Abc_Obj_t* query = bbFormula(node);
- d_aigOutputNode = Abc_NtkCreatePo(currentAigNtk());
- Abc_ObjAddFanin(d_aigOutputNode, query);
-
- simplifyAig();
- convertToCnfAndAssert();
- // no need to use abc anymore
-
- TimerStat::CodeTimer solveTimer(d_statistics.d_solveTime);
- prop::SatValue result = d_satSolver->solve();
-
- Assert(result != prop::SAT_VALUE_UNKNOWN);
- return result == prop::SAT_VALUE_TRUE;
-}
-
-
-void addAliases(Abc_Frame_t* pAbc);
-
-void AigBitblaster::simplifyAig() {
- TimerStat::CodeTimer simpTimer(d_statistics.d_simplificationTime);
-
- Abc_AigCleanup(currentAigM());
- Assert(Abc_NtkCheck(currentAigNtk()));
-
- const char* command = options::bitvectorAigSimplifications().c_str();
- Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame();
- Abc_FrameSetCurrentNetwork(pAbc, currentAigNtk());
-
- addAliases(pAbc);
- if ( Cmd_CommandExecute( pAbc, command ) ) {
- fprintf( stdout, "Cannot execute command \"%s\".\n", command );
- exit(-1);
- }
- s_abcAigNetwork = Abc_FrameReadNtk(pAbc);
-}
-
-
-void AigBitblaster::convertToCnfAndAssert() {
- TimerStat::CodeTimer cnfConversionTimer(d_statistics.d_cnfConversionTime);
-
- Aig_Man_t * pMan = NULL;
- Cnf_Dat_t * pCnf = NULL;
- Assert(Abc_NtkIsStrash(currentAigNtk()));
-
- // convert to the AIG manager
- pMan = Abc_NtkToDar(currentAigNtk(), 0, 0 );
- Abc_Stop();
-
- // // free old network
- // Abc_NtkDelete(currentAigNtk());
- // s_abcAigNetwork = NULL;
-
- Assert(pMan != NULL);
- Assert(Aig_ManCheck(pMan));
- pCnf = Cnf_DeriveFast( pMan, 0 );
-
- assertToSatSolver(pCnf);
-
- Cnf_DataFree( pCnf );
- Cnf_ManFree();
- Aig_ManStop(pMan);
-}
-
-void AigBitblaster::assertToSatSolver(Cnf_Dat_t* pCnf) {
- unsigned numVariables = pCnf->nVars;
- unsigned numClauses = pCnf->nClauses;
-
- d_statistics.d_numVariables += numVariables;
- d_statistics.d_numClauses += numClauses;
-
- // create variables in the sat solver
- std::vector<prop::SatVariable> sat_variables;
- for (unsigned i = 0; i < numVariables; ++i) {
- sat_variables.push_back(d_satSolver->newVar(false, false, false));
- }
-
- // construct clauses and add to sat solver
- int * pLit, * pStop;
- for (unsigned i = 0; i < numClauses; i++ ) {
- prop::SatClause clause;
- for (pLit = pCnf->pClauses[i], pStop = pCnf->pClauses[i+1]; pLit < pStop; pLit++ ) {
- int int_lit = Cnf_Lit2Var(*pLit);
- Assert(int_lit != 0);
- unsigned index = int_lit < 0? -int_lit : int_lit;
- Assert(index - 1 < sat_variables.size());
- prop::SatLiteral lit(sat_variables[index-1], int_lit < 0);
- clause.push_back(lit);
- }
- d_satSolver->addClause(clause, false);
- }
-}
-
-void addAliases(Abc_Frame_t* pAbc) {
- std::vector<std::string> aliases;
- aliases.push_back("alias b balance");
- aliases.push_back("alias rw rewrite");
- aliases.push_back("alias rwz rewrite -z");
- aliases.push_back("alias rf refactor");
- aliases.push_back("alias rfz refactor -z");
- aliases.push_back("alias re restructure");
- aliases.push_back("alias rez restructure -z");
- aliases.push_back("alias rs resub");
- aliases.push_back("alias rsz resub -z");
- aliases.push_back("alias rsk6 rs -K 6");
- aliases.push_back("alias rszk5 rsz -K 5");
- aliases.push_back("alias bl b -l");
- aliases.push_back("alias rwl rw -l");
- aliases.push_back("alias rwzl rwz -l");
- aliases.push_back("alias rwzl rwz -l");
- aliases.push_back("alias rfl rf -l");
- aliases.push_back("alias rfzl rfz -l");
- aliases.push_back("alias brw \"b; rw\"");
-
- for (unsigned i = 0; i < aliases.size(); ++i) {
- if ( Cmd_CommandExecute( pAbc, aliases[i].c_str() ) ) {
- fprintf( stdout, "Cannot execute command \"%s\".\n", aliases[i].c_str() );
- exit(-1);
- }
- }
-}
-
-bool AigBitblaster::hasBBAtom(TNode atom) const {
- return d_bbAtoms.find(atom) != d_bbAtoms.end();
-}
-
-void AigBitblaster::storeBBAtom(TNode atom, Abc_Obj_t* atom_bb) {
- d_bbAtoms.insert(std::make_pair(atom, atom_bb));
-}
-
-Abc_Obj_t* AigBitblaster::getBBAtom(TNode atom) const {
- Assert(hasBBAtom(atom));
- return d_bbAtoms.find(atom)->second;
-}
-
-AigBitblaster::Statistics::Statistics()
- : d_numClauses(smtStatisticsRegistry().registerInt(
- "theory::bv::AigBitblaster::numClauses")),
- d_numVariables(smtStatisticsRegistry().registerInt(
- "theory::bv::AigBitblaster::numVariables")),
- d_simplificationTime(smtStatisticsRegistry().registerTimer(
- "theory::bv::AigBitblaster::simplificationTime")),
- d_cnfConversionTime(smtStatisticsRegistry().registerTimer(
- "theory::bv::AigBitblaster::cnfConversionTime")),
- d_solveTime(smtStatisticsRegistry().registerTimer(
- "theory::bv::AigBitblaster::solveTime"))
-{
-}
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
-#endif // CVC5_USE_ABC
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Mathias Preiner, Andres Noetzli
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * AIG Bitblaster based on ABC.
- */
-
-#include "cvc5_private.h"
-
-#ifndef CVC5__THEORY__BV__BITBLAST__AIG_BITBLASTER_H
-#define CVC5__THEORY__BV__BITBLAST__AIG_BITBLASTER_H
-
-#include "theory/bv/bitblast/bitblaster.h"
-
-class Abc_Obj_t_;
-typedef Abc_Obj_t_ Abc_Obj_t;
-
-class Abc_Ntk_t_;
-typedef Abc_Ntk_t_ Abc_Ntk_t;
-
-class Abc_Aig_t_;
-typedef Abc_Aig_t_ Abc_Aig_t;
-
-class Cnf_Dat_t_;
-typedef Cnf_Dat_t_ Cnf_Dat_t;
-
-namespace cvc5 {
-namespace prop {
-class SatSolver;
-}
-namespace theory {
-namespace bv {
-
-#ifdef CVC5_USE_ABC
-
-class AigBitblaster : public TBitblaster<Abc_Obj_t*>
-{
- public:
- AigBitblaster();
- ~AigBitblaster();
-
- void makeVariable(TNode node, Bits& bits) override;
- void bbTerm(TNode node, Bits& bits) override;
- void bbAtom(TNode node) override;
- Abc_Obj_t* bbFormula(TNode formula);
- bool solve(TNode query);
- static Abc_Aig_t* currentAigM();
- static Abc_Ntk_t* currentAigNtk();
-
- private:
- typedef std::unordered_map<TNode, Abc_Obj_t*> TNodeAigMap;
- typedef std::unordered_map<Node, Abc_Obj_t*> NodeAigMap;
-
- static thread_local Abc_Ntk_t* s_abcAigNetwork;
- std::unique_ptr<context::Context> d_nullContext;
- std::unique_ptr<prop::SatSolver> d_satSolver;
- TNodeAigMap d_aigCache;
- NodeAigMap d_bbAtoms;
-
- NodeAigMap d_nodeToAigInput;
- // the thing we are checking for sat
- Abc_Obj_t* d_aigOutputNode;
-
- std::unique_ptr<MinisatEmptyNotify> d_notify;
-
- void addAtom(TNode atom);
- void simplifyAig();
- void storeBBAtom(TNode atom, Abc_Obj_t* atom_bb) override;
- Abc_Obj_t* getBBAtom(TNode atom) const override;
- bool hasBBAtom(TNode atom) const override;
- void cacheAig(TNode node, Abc_Obj_t* aig);
- bool hasAig(TNode node);
- Abc_Obj_t* getAig(TNode node);
- Abc_Obj_t* mkInput(TNode input);
- bool hasInput(TNode input);
- void convertToCnfAndAssert();
- void assertToSatSolver(Cnf_Dat_t* pCnf);
- Node getModelFromSatSolver(TNode a, bool fullModel) override
- {
- Unreachable();
- }
-
- prop::SatSolver* getSatSolver() override { return d_satSolver.get(); }
-
- class Statistics
- {
- public:
- IntStat d_numClauses;
- IntStat d_numVariables;
- TimerStat d_simplificationTime;
- TimerStat d_cnfConversionTime;
- TimerStat d_solveTime;
- Statistics();
- };
-
- Statistics d_statistics;
-};
-
-#else /* CVC5_USE_ABC */
-
-/**
- * Dummy version of the AigBitblaster class that cannot be instantiated s.t. we
- * can declare `std::unique_ptr<AigBitblaster>` without ABC.
- */
-class AigBitblaster : public TBitblaster<Abc_Obj_t*>
-{
- AigBitblaster() = delete;
-};
-
-#endif /* CVC5_USE_ABC */
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
-
-#endif // CVC5__THEORY__BV__BITBLAST__AIG_BITBLASTER_H
#include <vector>
#include "expr/node.h"
-#include "prop/bv_sat_solver_notify.h"
#include "prop/cnf_stream.h"
#include "prop/registrar.h"
#include "prop/sat_solver.h"
void invalidateModelCache();
};
-class MinisatEmptyNotify : public prop::BVSatSolverNotify
-{
- public:
- MinisatEmptyNotify() {}
- bool notify(prop::SatLiteral lit) override { return true; }
- void notify(prop::SatClause& clause) override {}
- void spendResource(Resource r) override
- {
- smt::currentResourceManager()->spendResource(r);
- }
-
- void safePoint(Resource r) override {}
-};
-
// Bitblaster implementation
template <class T>
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Mathias Preiner, Andres Noetzli
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Bitblaster for the eager bv solver.
- */
-
-#include "theory/bv/bitblast/eager_bitblaster.h"
-
-#include "cvc5_private.h"
-#include "options/base_options.h"
-#include "options/bv_options.h"
-#include "options/smt_options.h"
-#include "prop/cnf_stream.h"
-#include "prop/sat_solver_factory.h"
-#include "smt/smt_statistics_registry.h"
-#include "smt/solver_engine.h"
-#include "theory/bv/bv_solver_layered.h"
-#include "theory/bv/theory_bv.h"
-#include "theory/theory_model.h"
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-EagerBitblaster::EagerBitblaster(BVSolverLayered* theory_bv,
- context::Context* c)
- : TBitblaster<Node>(),
- d_context(c),
- d_satSolver(),
- d_bitblastingRegistrar(new BitblastingRegistrar(this)),
- d_bv(theory_bv),
- d_bbAtoms(),
- d_variables(),
- d_notify()
-{
- prop::SatSolver *solver = nullptr;
- switch (options::bvSatSolver())
- {
- case options::SatSolverMode::MINISAT:
- {
- prop::BVSatSolverInterface* minisat =
- prop::SatSolverFactory::createMinisat(
- d_nullContext.get(),
- smtStatisticsRegistry(),
- "theory::bv::EagerBitblaster::");
- d_notify.reset(new MinisatEmptyNotify());
- minisat->setNotify(d_notify.get());
- solver = minisat;
- break;
- }
- case options::SatSolverMode::CADICAL:
- solver = prop::SatSolverFactory::createCadical(
- smtStatisticsRegistry(), "theory::bv::EagerBitblaster::");
- break;
- case options::SatSolverMode::CRYPTOMINISAT:
- solver = prop::SatSolverFactory::createCryptoMinisat(
- smtStatisticsRegistry(), "theory::bv::EagerBitblaster::");
- break;
- case options::SatSolverMode::KISSAT:
- solver = prop::SatSolverFactory::createKissat(
- smtStatisticsRegistry(), "theory::bv::EagerBitblaster::");
- break;
- default: Unreachable() << "Unknown SAT solver type";
- }
- d_satSolver.reset(solver);
- ResourceManager* rm = smt::currentResourceManager();
- d_cnfStream.reset(new prop::CnfStream(d_satSolver.get(),
- d_bitblastingRegistrar.get(),
- d_nullContext.get(),
- nullptr,
- rm,
- prop::FormulaLitPolicy::INTERNAL,
- "EagerBitblaster"));
-}
-
-EagerBitblaster::~EagerBitblaster() {}
-
-void EagerBitblaster::bbFormula(TNode node)
-{
- /* For incremental eager solving we assume formulas at context levels > 1. */
- if (options::incrementalSolving() && d_context->getLevel() > 1)
- {
- d_cnfStream->ensureLiteral(node);
- }
- else
- {
- d_cnfStream->convertAndAssert(node, false, false);
- }
-}
-
-/**
- * Bitblasts the atom, assigns it a marker literal, adding it to the SAT solver
- * NOTE: duplicate clauses are not detected because of marker literal
- * @param node the atom to be bitblasted
- *
- */
-void EagerBitblaster::bbAtom(TNode node)
-{
- node = node.getKind() == kind::NOT ? node[0] : node;
- if (node.getKind() == kind::BITVECTOR_BITOF
- || node.getKind() == kind::CONST_BOOLEAN || hasBBAtom(node))
- {
- return;
- }
-
- Debug("bitvector-bitblast") << "Bitblasting node " << node << "\n";
-
- // the bitblasted definition of the atom
- Node normalized = Rewriter::rewrite(node);
- Node atom_bb =
- normalized.getKind() != kind::CONST_BOOLEAN
- ? d_atomBBStrategies[normalized.getKind()](normalized, this)
- : normalized;
-
- atom_bb = Rewriter::rewrite(atom_bb);
-
- // asserting that the atom is true iff the definition holds
- Node atom_definition =
- NodeManager::currentNM()->mkNode(kind::EQUAL, node, atom_bb);
-
- AlwaysAssert(options::bitblastMode() == options::BitblastMode::EAGER);
- storeBBAtom(node, atom_bb);
- d_cnfStream->convertAndAssert(atom_definition, false, false);
-}
-
-void EagerBitblaster::storeBBAtom(TNode atom, Node atom_bb) {
- d_bbAtoms.insert(atom);
-}
-
-void EagerBitblaster::storeBBTerm(TNode node, const Bits& bits) {
- d_termCache.insert(std::make_pair(node, bits));
-}
-
-bool EagerBitblaster::hasBBAtom(TNode atom) const {
- return d_bbAtoms.find(atom) != d_bbAtoms.end();
-}
-
-void EagerBitblaster::bbTerm(TNode node, Bits& bits) {
- Assert(node.getType().isBitVector());
-
- if (hasBBTerm(node)) {
- getBBTerm(node, bits);
- return;
- }
-
- d_bv->spendResource(Resource::BitblastStep);
- Debug("bitvector-bitblast") << "Bitblasting node " << node << "\n";
-
- d_termBBStrategies[node.getKind()](node, bits, this);
-
- Assert(bits.size() == utils::getSize(node));
-
- storeBBTerm(node, bits);
-}
-
-void EagerBitblaster::makeVariable(TNode var, Bits& bits) {
- Assert(bits.size() == 0);
- for (unsigned i = 0; i < utils::getSize(var); ++i) {
- bits.push_back(utils::mkBitOf(var, i));
- }
- d_variables.insert(var);
-}
-
-Node EagerBitblaster::getBBAtom(TNode node) const { return node; }
-
-/**
- * Calls the solve method for the Sat Solver.
- *
- * @return true for sat, and false for unsat
- */
-
-bool EagerBitblaster::solve() {
- if (Trace.isOn("bitvector")) {
- Trace("bitvector") << "EagerBitblaster::solve(). \n";
- }
- Debug("bitvector") << "EagerBitblaster::solve(). \n";
- // TODO: clear some memory
- // if (something) {
- // NodeManager* nm= NodeManager::currentNM();
- // Rewriter::garbageCollect();
- // nm->reclaimZombiesUntil(options::zombieHuntThreshold());
- // }
- return prop::SAT_VALUE_TRUE == d_satSolver->solve();
-}
-
-bool EagerBitblaster::solve(const std::vector<Node>& assumptions)
-{
- std::vector<prop::SatLiteral> assumpts;
- for (const Node& assumption : assumptions)
- {
- Assert(d_cnfStream->hasLiteral(assumption));
- assumpts.push_back(d_cnfStream->getLiteral(assumption));
- }
- return prop::SAT_VALUE_TRUE == d_satSolver->solve(assumpts);
-}
-
-/**
- * Returns the value a is currently assigned to in the SAT solver
- * or null if the value is completely unassigned.
- *
- * @param a
- * @param fullModel whether to create a "full model," i.e., add
- * constants to equivalence classes that don't already have them
- *
- * @return
- */
-Node EagerBitblaster::getModelFromSatSolver(TNode a, bool fullModel) {
- if (!hasBBTerm(a)) {
- return fullModel ? utils::mkConst(utils::getSize(a), 0u) : Node();
- }
-
- Bits bits;
- getBBTerm(a, bits);
- Integer value(0);
- for (int i = bits.size() - 1; i >= 0; --i) {
- prop::SatValue bit_value;
- if (d_cnfStream->hasLiteral(bits[i])) {
- prop::SatLiteral bit = d_cnfStream->getLiteral(bits[i]);
- bit_value = d_satSolver->value(bit);
- Assert(bit_value != prop::SAT_VALUE_UNKNOWN);
- } else {
- if (!fullModel) return Node();
- // unconstrained bits default to false
- bit_value = prop::SAT_VALUE_FALSE;
- }
- Integer bit_int =
- bit_value == prop::SAT_VALUE_TRUE ? Integer(1) : Integer(0);
- value = value * 2 + bit_int;
- }
- return utils::mkConst(bits.size(), value);
-}
-
-bool EagerBitblaster::collectModelInfo(TheoryModel* m, bool fullModel)
-{
- NodeManager* nm = NodeManager::currentNM();
-
- // Collect the values for the bit-vector variables
- TNodeSet::iterator it = d_variables.begin();
- for (; it != d_variables.end(); ++it) {
- TNode var = *it;
- if (d_bv->isLeaf(var) || isSharedTerm(var) ||
- (var.isVar() && var.getType().isBoolean())) {
- // only shared terms could not have been bit-blasted
- Assert(hasBBTerm(var) || isSharedTerm(var));
-
- Node const_value = getModelFromSatSolver(var, true);
-
- if (const_value != Node()) {
- Debug("bitvector-model")
- << "EagerBitblaster::collectModelInfo (assert (= " << var << " "
- << const_value << "))\n";
- if (!m->assertEquality(var, const_value, true))
- {
- return false;
- }
- }
- }
- }
-
- // Collect the values for the Boolean variables
- std::vector<TNode> vars;
- d_cnfStream->getBooleanVariables(vars);
- for (TNode var : vars)
- {
- Assert(d_cnfStream->hasLiteral(var));
- prop::SatLiteral bit = d_cnfStream->getLiteral(var);
- prop::SatValue value = d_satSolver->value(bit);
- Assert(value != prop::SAT_VALUE_UNKNOWN);
- if (!m->assertEquality(
- var, nm->mkConst(value == prop::SAT_VALUE_TRUE), true))
- {
- return false;
- }
- }
- return true;
-}
-
-bool EagerBitblaster::isSharedTerm(TNode node) {
- return d_bv->d_sharedTermsSet.find(node) != d_bv->d_sharedTermsSet.end();
-}
-
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Mathias Preiner, Liana Hadarean, Tim King
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Bitblaster for the eager BV solver.
- */
-
-#include "cvc5_private.h"
-
-#ifndef CVC5__THEORY__BV__BITBLAST__EAGER_BITBLASTER_H
-#define CVC5__THEORY__BV__BITBLAST__EAGER_BITBLASTER_H
-
-#include <memory>
-#include <unordered_set>
-
-#include "theory/bv/bitblast/bitblaster.h"
-
-#include "prop/sat_solver.h"
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-class BitblastingRegistrar;
-class BVSolverLayered;
-
-class EagerBitblaster : public TBitblaster<Node>
-{
- public:
- EagerBitblaster(BVSolverLayered* theory_bv, context::Context* context);
- ~EagerBitblaster();
-
- void addAtom(TNode atom);
- void makeVariable(TNode node, Bits& bits) override;
- void bbTerm(TNode node, Bits& bits) override;
- void bbAtom(TNode node) override;
- Node getBBAtom(TNode node) const override;
- bool hasBBAtom(TNode atom) const override;
- void bbFormula(TNode formula);
- void storeBBAtom(TNode atom, Node atom_bb) override;
- void storeBBTerm(TNode node, const Bits& bits) override;
-
- bool assertToSat(TNode node, bool propagate = true);
- bool solve();
- bool solve(const std::vector<Node>& assumptions);
- bool collectModelInfo(TheoryModel* m, bool fullModel);
-
- private:
- context::Context* d_context;
-
- typedef std::unordered_set<TNode> TNodeSet;
- std::unique_ptr<prop::SatSolver> d_satSolver;
- std::unique_ptr<BitblastingRegistrar> d_bitblastingRegistrar;
-
- BVSolverLayered* d_bv;
- TNodeSet d_bbAtoms;
- TNodeSet d_variables;
-
- // This is either an MinisatEmptyNotify or NULL.
- std::unique_ptr<MinisatEmptyNotify> d_notify;
-
- Node getModelFromSatSolver(TNode a, bool fullModel) override;
- prop::SatSolver* getSatSolver() override { return d_satSolver.get(); }
- bool isSharedTerm(TNode node);
-};
-
-class BitblastingRegistrar : public prop::Registrar
-{
- public:
- BitblastingRegistrar(EagerBitblaster* bb) : d_bitblaster(bb) {}
- void preRegister(Node n) override { d_bitblaster->bbAtom(n); }
-
- private:
- EagerBitblaster* d_bitblaster;
-};
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
-#endif // CVC5__THEORY__BV__BITBLAST__EAGER_BITBLASTER_H
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Aina Niemetz, Mathias Preiner
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Bitblaster for the layered BV solver.
- */
-
-#include "theory/bv/bitblast/lazy_bitblaster.h"
-
-#include "cvc5_private.h"
-#include "options/bv_options.h"
-#include "prop/cnf_stream.h"
-#include "prop/sat_solver.h"
-#include "prop/sat_solver_factory.h"
-#include "smt/smt_statistics_registry.h"
-#include "smt/solver_engine.h"
-#include "theory/bv/abstraction.h"
-#include "theory/bv/bv_solver_layered.h"
-#include "theory/bv/theory_bv.h"
-#include "theory/bv/theory_bv_utils.h"
-#include "theory/rewriter.h"
-#include "theory/theory_model.h"
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-namespace {
-
-/* Determine the number of uncached nodes that a given node consists of. */
-uint64_t numNodes(TNode node, utils::NodeSet& seen)
-{
- std::vector<TNode> stack;
- uint64_t res = 0;
-
- stack.push_back(node);
- while (!stack.empty())
- {
- Node n = stack.back();
- stack.pop_back();
-
- if (seen.find(n) != seen.end()) continue;
-
- res += 1;
- seen.insert(n);
- stack.insert(stack.end(), n.begin(), n.end());
- }
- return res;
-}
-}
-
-TLazyBitblaster::TLazyBitblaster(context::Context* c,
- bv::BVSolverLayered* bv,
- const std::string name,
- bool emptyNotify)
- : TBitblaster<Node>(),
- d_bv(bv),
- d_ctx(c),
- d_nullRegistrar(new prop::NullRegistrar()),
- d_assertedAtoms(new (true) context::CDList<prop::SatLiteral>(c)),
- d_explanations(new (true) ExplanationMap(c)),
- d_variables(),
- d_bbAtoms(),
- d_abstraction(NULL),
- d_emptyNotify(emptyNotify),
- d_fullModelAssertionLevel(c, 0),
- d_name(name),
- d_statistics(name + "::")
-{
- d_satSolver.reset(prop::SatSolverFactory::createMinisat(
- c, smtStatisticsRegistry(), name + "::"));
-
- ResourceManager* rm = smt::currentResourceManager();
- d_cnfStream.reset(new prop::CnfStream(d_satSolver.get(),
- d_nullRegistrar.get(),
- d_nullContext.get(),
- nullptr,
- rm,
- prop::FormulaLitPolicy::INTERNAL,
- "LazyBitblaster"));
-
- d_satSolverNotify.reset(
- d_emptyNotify
- ? (prop::BVSatSolverNotify*)new MinisatEmptyNotify()
- : (prop::BVSatSolverNotify*)new MinisatNotify(
- d_cnfStream.get(), bv, this));
-
- d_satSolver->setNotify(d_satSolverNotify.get());
-}
-
-void TLazyBitblaster::setAbstraction(AbstractionModule* abs) {
- d_abstraction = abs;
-}
-
-TLazyBitblaster::~TLazyBitblaster()
-{
- d_assertedAtoms->deleteSelf();
- d_explanations->deleteSelf();
-}
-
-
-/**
- * Bitblasts the atom, assigns it a marker literal, adding it to the SAT solver
- * NOTE: duplicate clauses are not detected because of marker literal
- * @param node the atom to be bitblasted
- *
- */
-void TLazyBitblaster::bbAtom(TNode node)
-{
- NodeManager* nm = NodeManager::currentNM();
- node = node.getKind() == kind::NOT ? node[0] : node;
-
- if (hasBBAtom(node))
- {
- return;
- }
-
- // make sure it is marked as an atom
- addAtom(node);
-
- Debug("bitvector-bitblast") << "Bitblasting node " << node << "\n";
- ++d_statistics.d_numAtoms;
-
- /// if we are using bit-vector abstraction bit-blast the original
- /// interpretation
- if (options::bvAbstraction() && d_abstraction != NULL
- && d_abstraction->isAbstraction(node))
- {
- // node must be of the form P(args) = bv1
- Node expansion = Rewriter::rewrite(d_abstraction->getInterpretation(node));
-
- Node atom_bb;
- if (expansion.getKind() == kind::CONST_BOOLEAN)
- {
- atom_bb = expansion;
- }
- else
- {
- Assert(expansion.getKind() == kind::AND);
- std::vector<Node> atoms;
- for (unsigned i = 0; i < expansion.getNumChildren(); ++i)
- {
- Node normalized_i = Rewriter::rewrite(expansion[i]);
- Node atom_i =
- normalized_i.getKind() != kind::CONST_BOOLEAN
- ? Rewriter::rewrite(d_atomBBStrategies[normalized_i.getKind()](
- normalized_i, this))
- : normalized_i;
- atoms.push_back(atom_i);
- }
- atom_bb = utils::mkAnd(atoms);
- }
- Assert(!atom_bb.isNull());
- Node atom_definition = nm->mkNode(kind::EQUAL, node, atom_bb);
- storeBBAtom(node, atom_bb);
- d_cnfStream->convertAndAssert(atom_definition, false, false);
- return;
- }
-
- // the bitblasted definition of the atom
- Node normalized = Rewriter::rewrite(node);
- Node atom_bb =
- normalized.getKind() != kind::CONST_BOOLEAN
- ? d_atomBBStrategies[normalized.getKind()](normalized, this)
- : normalized;
-
- atom_bb = Rewriter::rewrite(atom_bb);
-
- // asserting that the atom is true iff the definition holds
- Node atom_definition = nm->mkNode(kind::EQUAL, node, atom_bb);
- storeBBAtom(node, atom_bb);
- d_cnfStream->convertAndAssert(atom_definition, false, false);
-}
-
-void TLazyBitblaster::storeBBAtom(TNode atom, Node atom_bb) {
- d_bbAtoms.insert(atom);
-}
-
-void TLazyBitblaster::storeBBTerm(TNode node, const Bits& bits) {
- d_termCache.insert(std::make_pair(node, bits));
-}
-
-
-bool TLazyBitblaster::hasBBAtom(TNode atom) const {
- return d_bbAtoms.find(atom) != d_bbAtoms.end();
-}
-
-
-void TLazyBitblaster::makeVariable(TNode var, Bits& bits) {
- Assert(bits.size() == 0);
- for (unsigned i = 0; i < utils::getSize(var); ++i) {
- bits.push_back(utils::mkBitOf(var, i));
- }
- d_variables.insert(var);
-}
-
-uint64_t TLazyBitblaster::computeAtomWeight(TNode node, NodeSet& seen)
-{
- node = node.getKind() == kind::NOT ? node[0] : node;
- if (!utils::isBitblastAtom(node)) { return 0; }
- Node atom_bb =
- Rewriter::rewrite(d_atomBBStrategies[node.getKind()](node, this));
- uint64_t size = numNodes(atom_bb, seen);
- return size;
-}
-
-// cnf conversion ensures the atom represents itself
-Node TLazyBitblaster::getBBAtom(TNode node) const {
- return node;
-}
-
-void TLazyBitblaster::bbTerm(TNode node, Bits& bits) {
-
- if (hasBBTerm(node)) {
- getBBTerm(node, bits);
- return;
- }
- Assert(node.getType().isBitVector());
-
- d_bv->spendResource(Resource::BitblastStep);
- Debug("bitvector-bitblast") << "Bitblasting term " << node <<"\n";
- ++d_statistics.d_numTerms;
-
- d_termBBStrategies[node.getKind()] (node, bits,this);
-
- Assert(bits.size() == utils::getSize(node));
-
- storeBBTerm(node, bits);
-}
-/// Public methods
-
-void TLazyBitblaster::addAtom(TNode atom) {
- d_cnfStream->ensureLiteral(atom);
- prop::SatLiteral lit = d_cnfStream->getLiteral(atom);
- d_satSolver->addMarkerLiteral(lit);
-}
-
-void TLazyBitblaster::explain(TNode atom, std::vector<TNode>& explanation) {
- prop::SatLiteral lit = d_cnfStream->getLiteral(atom);
-
- ++(d_statistics.d_numExplainedPropagations);
- if (options::bvEagerExplanations()) {
- Assert(d_explanations->find(lit) != d_explanations->end());
- const std::vector<prop::SatLiteral>& literal_explanation = (*d_explanations)[lit].get();
- for (unsigned i = 0; i < literal_explanation.size(); ++i) {
- explanation.push_back(d_cnfStream->getNode(literal_explanation[i]));
- }
- return;
- }
-
- std::vector<prop::SatLiteral> literal_explanation;
- d_satSolver->explain(lit, literal_explanation);
- for (unsigned i = 0; i < literal_explanation.size(); ++i) {
- explanation.push_back(d_cnfStream->getNode(literal_explanation[i]));
- }
-}
-
-
-/*
- * Asserts the clauses corresponding to the atom to the Sat Solver
- * by turning on the marker literal (i.e. setting it to false)
- * @param node the atom to be asserted
- *
- */
-
-bool TLazyBitblaster::propagate() {
- return d_satSolver->propagate() == prop::SAT_VALUE_TRUE;
-}
-
-bool TLazyBitblaster::assertToSat(TNode lit, bool propagate) {
- // strip the not
- TNode atom;
- if (lit.getKind() == kind::NOT) {
- atom = lit[0];
- } else {
- atom = lit;
- }
- Assert(utils::isBitblastAtom(atom));
-
- Assert(hasBBAtom(atom));
-
- prop::SatLiteral markerLit = d_cnfStream->getLiteral(atom);
-
- if(lit.getKind() == kind::NOT) {
- markerLit = ~markerLit;
- }
-
- Debug("bitvector-bb")
- << "BVSolverLayered::TLazyBitblaster::assertToSat asserting node: "
- << atom << "\n";
- Debug("bitvector-bb")
- << "BVSolverLayered::TLazyBitblaster::assertToSat with literal: "
- << markerLit << "\n";
-
- prop::SatValue ret = d_satSolver->assertAssumption(markerLit, propagate);
-
- d_assertedAtoms->push_back(markerLit);
-
- return ret == prop::SAT_VALUE_TRUE || ret == prop::SAT_VALUE_UNKNOWN;
-}
-
-/**
- * Calls the solve method for the Sat Solver.
- * passing it the marker literals to be asserted
- *
- * @return true for sat, and false for unsat
- */
-
-bool TLazyBitblaster::solve() {
- if (Trace.isOn("bitvector")) {
- Trace("bitvector") << "TLazyBitblaster::solve() asserted atoms ";
- context::CDList<prop::SatLiteral>::const_iterator it = d_assertedAtoms->begin();
- for (; it != d_assertedAtoms->end(); ++it) {
- Trace("bitvector") << " " << d_cnfStream->getNode(*it) << "\n";
- }
- }
- Debug("bitvector") << "TLazyBitblaster::solve() asserted atoms " << d_assertedAtoms->size() <<"\n";
- d_fullModelAssertionLevel.set(d_bv->numAssertions());
- return prop::SAT_VALUE_TRUE == d_satSolver->solve();
-}
-
-prop::SatValue TLazyBitblaster::solveWithBudget(unsigned long budget) {
- if (Trace.isOn("bitvector")) {
- Trace("bitvector") << "TLazyBitblaster::solveWithBudget() asserted atoms ";
- context::CDList<prop::SatLiteral>::const_iterator it = d_assertedAtoms->begin();
- for (; it != d_assertedAtoms->end(); ++it) {
- Trace("bitvector") << " " << d_cnfStream->getNode(*it) << "\n";
- }
- }
- Debug("bitvector") << "TLazyBitblaster::solveWithBudget() asserted atoms " << d_assertedAtoms->size() <<"\n";
- return d_satSolver->solve(budget);
-}
-
-void TLazyBitblaster::getConflict(std::vector<TNode>& conflict)
-{
- NodeManager* nm = NodeManager::currentNM();
- prop::SatClause conflictClause;
- d_satSolver->getUnsatCore(conflictClause);
-
- for (unsigned i = 0; i < conflictClause.size(); i++)
- {
- prop::SatLiteral lit = conflictClause[i];
- TNode atom = d_cnfStream->getNode(lit);
- Node not_atom;
- if (atom.getKind() == kind::NOT)
- {
- not_atom = atom[0];
- }
- else
- {
- not_atom = nm->mkNode(kind::NOT, atom);
- }
- conflict.push_back(not_atom);
- }
-}
-
-TLazyBitblaster::Statistics::Statistics(const std::string& prefix)
- : d_numTermClauses(
- smtStatisticsRegistry().registerInt(prefix + "NumTermSatClauses")),
- d_numAtomClauses(
- smtStatisticsRegistry().registerInt(prefix + "NumAtomSatClauses")),
- d_numTerms(
- smtStatisticsRegistry().registerInt(prefix + "NumBitblastedTerms")),
- d_numAtoms(
- smtStatisticsRegistry().registerInt(prefix + "NumBitblastedAtoms")),
- d_numExplainedPropagations(smtStatisticsRegistry().registerInt(
- prefix + "NumExplainedPropagations")),
- d_numBitblastingPropagations(smtStatisticsRegistry().registerInt(
- prefix + "NumBitblastingPropagations")),
- d_bitblastTimer(
- smtStatisticsRegistry().registerTimer(prefix + "BitblastTimer"))
-{
-}
-
-bool TLazyBitblaster::MinisatNotify::notify(prop::SatLiteral lit) {
- if(options::bvEagerExplanations()) {
- // compute explanation
- if (d_lazyBB->d_explanations->find(lit) == d_lazyBB->d_explanations->end()) {
- std::vector<prop::SatLiteral> literal_explanation;
- d_lazyBB->d_satSolver->explain(lit, literal_explanation);
- d_lazyBB->d_explanations->insert(lit, literal_explanation);
- } else {
- // we propagated it at a lower level
- return true;
- }
- }
- ++(d_lazyBB->d_statistics.d_numBitblastingPropagations);
- TNode atom = d_cnf->getNode(lit);
- return d_bv->storePropagation(atom, SUB_BITBLAST);
-}
-
-void TLazyBitblaster::MinisatNotify::notify(prop::SatClause& clause) {
- if (clause.size() > 1) {
- NodeBuilder lemmab(kind::OR);
- for (unsigned i = 0; i < clause.size(); ++ i) {
- lemmab << d_cnf->getNode(clause[i]);
- }
- Node lemma = lemmab;
- d_bv->d_im.lemma(lemma, InferenceId::BV_LAYERED_LEMMA);
- } else {
- d_bv->d_im.lemma(d_cnf->getNode(clause[0]), InferenceId::BV_LAYERED_LEMMA);
- }
-}
-
-void TLazyBitblaster::MinisatNotify::spendResource(Resource r)
-{
- d_bv->spendResource(r);
-}
-
-void TLazyBitblaster::MinisatNotify::safePoint(Resource r)
-{
- d_bv->d_im.safePoint(r);
-}
-
-EqualityStatus TLazyBitblaster::getEqualityStatus(TNode a, TNode b)
-{
- int numAssertions = d_bv->numAssertions();
- bool has_full_model =
- numAssertions != 0 && d_fullModelAssertionLevel.get() == numAssertions;
-
- Debug("bv-equality-status")
- << "TLazyBitblaster::getEqualityStatus " << a << " = " << b << "\n";
- Debug("bv-equality-status")
- << "BVSatSolver has full model? " << has_full_model << "\n";
-
- // First check if it trivially rewrites to false/true
- Node a_eq_b =
- Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::EQUAL, a, b));
-
- if (a_eq_b == utils::mkFalse()) return theory::EQUALITY_FALSE;
- if (a_eq_b == utils::mkTrue()) return theory::EQUALITY_TRUE;
-
- if (!has_full_model)
- {
- return theory::EQUALITY_UNKNOWN;
- }
-
- // Check if cache is valid (invalidated in check and pops)
- if (d_bv->d_invalidateModelCache.get())
- {
- invalidateModelCache();
- }
- d_bv->d_invalidateModelCache.set(false);
-
- Node a_value = getTermModel(a, true);
- Node b_value = getTermModel(b, true);
-
- Assert(a_value.isConst() && b_value.isConst());
-
- if (a_value == b_value)
- {
- Debug("bv-equality-status") << "theory::EQUALITY_TRUE_IN_MODEL\n";
- return theory::EQUALITY_TRUE_IN_MODEL;
- }
- Debug("bv-equality-status") << "theory::EQUALITY_FALSE_IN_MODEL\n";
- return theory::EQUALITY_FALSE_IN_MODEL;
-}
-
-bool TLazyBitblaster::isSharedTerm(TNode node) {
- return d_bv->d_sharedTermsSet.find(node) != d_bv->d_sharedTermsSet.end();
-}
-
-bool TLazyBitblaster::hasValue(TNode a) {
- Assert(hasBBTerm(a));
- Bits bits;
- getBBTerm(a, bits);
- for (int i = bits.size() -1; i >= 0; --i) {
- prop::SatValue bit_value;
- if (d_cnfStream->hasLiteral(bits[i])) {
- prop::SatLiteral bit = d_cnfStream->getLiteral(bits[i]);
- bit_value = d_satSolver->value(bit);
- if (bit_value == prop::SAT_VALUE_UNKNOWN)
- return false;
- } else {
- return false;
- }
- }
- return true;
-}
-/**
- * Returns the value a is currently assigned to in the SAT solver
- * or null if the value is completely unassigned.
- *
- * @param a
- * @param fullModel whether to create a "full model," i.e., add
- * constants to equivalence classes that don't already have them
- *
- * @return
- */
-Node TLazyBitblaster::getModelFromSatSolver(TNode a, bool fullModel) {
- if (!hasBBTerm(a)) {
- return fullModel? utils::mkConst(utils::getSize(a), 0u) : Node();
- }
-
- Bits bits;
- getBBTerm(a, bits);
- Integer value(0);
- for (int i = bits.size() -1; i >= 0; --i) {
- prop::SatValue bit_value;
- if (d_cnfStream->hasLiteral(bits[i])) {
- prop::SatLiteral bit = d_cnfStream->getLiteral(bits[i]);
- bit_value = d_satSolver->value(bit);
- Assert(bit_value != prop::SAT_VALUE_UNKNOWN);
- } else {
- if (!fullModel) return Node();
- // unconstrained bits default to false
- bit_value = prop::SAT_VALUE_FALSE;
- }
- Integer bit_int = bit_value == prop::SAT_VALUE_TRUE ? Integer(1) : Integer(0);
- value = value * 2 + bit_int;
- }
- return utils::mkConst(bits.size(), value);
-}
-
-bool TLazyBitblaster::collectModelValues(TheoryModel* m,
- const std::set<Node>& termSet)
-{
- for (std::set<Node>::const_iterator it = termSet.begin(); it != termSet.end(); ++it) {
- TNode var = *it;
- // not actually a leaf of the bit-vector theory
- if (d_variables.find(var) == d_variables.end())
- continue;
-
- Assert(Theory::theoryOf(var) == theory::THEORY_BV || isSharedTerm(var));
- // only shared terms could not have been bit-blasted
- Assert(hasBBTerm(var) || isSharedTerm(var));
-
- Node const_value = getModelFromSatSolver(var, true);
- Assert(const_value.isNull() || const_value.isConst());
- if(const_value != Node()) {
- Debug("bitvector-model")
- << "TLazyBitblaster::collectModelValues (assert (= " << var << " "
- << const_value << "))\n";
- if (!m->assertEquality(var, const_value, true))
- {
- return false;
- }
- }
- }
- return true;
-}
-
-void TLazyBitblaster::clearSolver() {
- Assert(d_ctx->getLevel() == 0);
- d_assertedAtoms->deleteSelf();
- d_assertedAtoms = new(true) context::CDList<prop::SatLiteral>(d_ctx);
- d_explanations->deleteSelf();
- d_explanations = new(true) ExplanationMap(d_ctx);
- d_bbAtoms.clear();
- d_variables.clear();
- d_termCache.clear();
-
- invalidateModelCache();
- // recreate sat solver
- d_satSolver.reset(
- prop::SatSolverFactory::createMinisat(d_ctx, smtStatisticsRegistry()));
- ResourceManager* rm = smt::currentResourceManager();
- d_cnfStream.reset(new prop::CnfStream(d_satSolver.get(),
- d_nullRegistrar.get(),
- d_nullContext.get(),
- nullptr,
- rm));
- d_satSolverNotify.reset(
- d_emptyNotify
- ? (prop::BVSatSolverNotify*)new MinisatEmptyNotify()
- : (prop::BVSatSolverNotify*)new MinisatNotify(
- d_cnfStream.get(), d_bv, this));
- d_satSolver->setNotify(d_satSolverNotify.get());
-}
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Mathias Preiner, Liana Hadarean, Clark Barrett
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Bitblaster for the lazy bv solver.
- */
-
-#include "cvc5_private.h"
-
-#ifndef CVC5__THEORY__BV__BITBLAST__LAZY_BITBLASTER_H
-#define CVC5__THEORY__BV__BITBLAST__LAZY_BITBLASTER_H
-
-#include "theory/bv/bitblast/bitblaster.h"
-
-#include "context/cdhashmap.h"
-#include "context/cdlist.h"
-#include "prop/bv_sat_solver_notify.h"
-#include "theory/bv/abstraction.h"
-
-namespace cvc5 {
-namespace prop {
-class CnfStream;
-class NullRegistrat;
-}
-namespace theory {
-namespace bv {
-
-class BVSolverLayered;
-
-class TLazyBitblaster : public TBitblaster<Node>
-{
- public:
- void bbTerm(TNode node, Bits& bits) override;
- void bbAtom(TNode node) override;
- Node getBBAtom(TNode atom) const override;
- void storeBBAtom(TNode atom, Node atom_bb) override;
- void storeBBTerm(TNode node, const Bits& bits) override;
- bool hasBBAtom(TNode atom) const override;
-
- TLazyBitblaster(context::Context* c,
- BVSolverLayered* bv,
- const std::string name = "",
- bool emptyNotify = false);
- ~TLazyBitblaster();
- /**
- * Pushes the assumption literal associated with node to the SAT
- * solver assumption queue.
- *
- * @param node assumption
- * @param propagate run bcp or not
- *
- * @return false if a conflict detected
- */
- bool assertToSat(TNode node, bool propagate = true);
- bool propagate();
- bool solve();
- prop::SatValue solveWithBudget(unsigned long conflict_budget);
- void getConflict(std::vector<TNode>& conflict);
- void explain(TNode atom, std::vector<TNode>& explanation);
- void setAbstraction(AbstractionModule* abs);
-
- theory::EqualityStatus getEqualityStatus(TNode a, TNode b);
-
- /**
- * Adds a constant value for each bit-blasted variable in the model.
- *
- * @param m the model
- * @param termSet the set of relevant terms
- */
- bool collectModelValues(TheoryModel* m,
- const std::set<Node>& termSet);
-
- typedef TNodeSet::const_iterator vars_iterator;
- vars_iterator beginVars() { return d_variables.begin(); }
- vars_iterator endVars() { return d_variables.end(); }
-
- /**
- * Creates the bits corresponding to the variable (or non-bv term).
- *
- * @param var
- */
- void makeVariable(TNode var, Bits& bits) override;
-
- bool isSharedTerm(TNode node);
- uint64_t computeAtomWeight(TNode node, NodeSet& seen);
- /**
- * Deletes SatSolver and CnfCache, but maintains bit-blasting
- * terms cache.
- *
- */
- void clearSolver();
-
- private:
- typedef std::vector<Node> Bits;
- typedef context::CDList<prop::SatLiteral> AssertionList;
- typedef context::CDHashMap<prop::SatLiteral,
- std::vector<prop::SatLiteral>,
- prop::SatLiteralHashFunction>
- ExplanationMap;
- /** This class gets callbacks from minisat on propagations */
- class MinisatNotify : public prop::BVSatSolverNotify
- {
- prop::CnfStream* d_cnf;
- BVSolverLayered* d_bv;
- TLazyBitblaster* d_lazyBB;
-
- public:
- MinisatNotify(prop::CnfStream* cnf,
- BVSolverLayered* bv,
- TLazyBitblaster* lbv)
- : d_cnf(cnf), d_bv(bv), d_lazyBB(lbv)
- {
- }
-
- bool notify(prop::SatLiteral lit) override;
- void notify(prop::SatClause& clause) override;
- void spendResource(Resource r) override;
- void safePoint(Resource r) override;
- };
-
- BVSolverLayered* d_bv;
- context::Context* d_ctx;
-
- std::unique_ptr<prop::NullRegistrar> d_nullRegistrar;
- std::unique_ptr<prop::BVSatSolverInterface> d_satSolver;
- std::unique_ptr<prop::BVSatSolverNotify> d_satSolverNotify;
-
- AssertionList*
- d_assertedAtoms; /**< context dependent list storing the atoms
- currently asserted by the DPLL SAT solver. */
- ExplanationMap* d_explanations; /**< context dependent list of explanations
- for the propagated literals. Only used when
- bvEagerPropagate option enabled. */
- TNodeSet d_variables;
- TNodeSet d_bbAtoms;
- AbstractionModule* d_abstraction;
- bool d_emptyNotify;
-
- // The size of the fact queue when we most recently called solve() in the
- // bit-vector SAT solver. This is the level at which we should have
- // a full model in the bv SAT solver.
- context::CDO<int> d_fullModelAssertionLevel;
-
- void addAtom(TNode atom);
- bool hasValue(TNode a);
- Node getModelFromSatSolver(TNode a, bool fullModel) override;
- prop::SatSolver* getSatSolver() override { return d_satSolver.get(); }
-
- class Statistics
- {
- public:
- IntStat d_numTermClauses, d_numAtomClauses;
- IntStat d_numTerms, d_numAtoms;
- IntStat d_numExplainedPropagations;
- IntStat d_numBitblastingPropagations;
- TimerStat d_bitblastTimer;
- Statistics(const std::string& name);
- };
- std::string d_name;
-
- // NOTE: d_statistics is public since d_bitblastTimer needs to be initalized
- // prior to calling bbAtom. As it is now, the timer can't be initialized
- // in bbAtom since the method is called recursively and the timer would
- // be initialized multiple times, which is not allowed.
- public:
- Statistics d_statistics;
-};
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
-#endif // CVC5__THEORY__BV__BITBLAST__LAZY_BITBLASTER_H
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Mathias Preiner, Liana Hadarean, Tim King
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Eager bit-blasting solver.
- */
-
-#include "theory/bv/bv_eager_solver.h"
-
-#include "options/base_options.h"
-#include "options/bv_options.h"
-#include "options/smt_options.h"
-#include "theory/bv/bitblast/aig_bitblaster.h"
-#include "theory/bv/bitblast/eager_bitblaster.h"
-
-using namespace std;
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-EagerBitblastSolver::EagerBitblastSolver(context::Context* c,
- BVSolverLayered* bv)
- : d_assertionSet(c),
- d_assumptionSet(c),
- d_context(c),
- d_bitblaster(),
- d_aigBitblaster(),
- d_useAig(options::bitvectorAig()),
- d_bv(bv)
-{
-}
-
-EagerBitblastSolver::~EagerBitblastSolver() {}
-
-void EagerBitblastSolver::turnOffAig() {
- Assert(d_aigBitblaster == nullptr && d_bitblaster == nullptr);
- d_useAig = false;
-}
-
-void EagerBitblastSolver::initialize() {
- Assert(!isInitialized());
- if (d_useAig) {
-#ifdef CVC5_USE_ABC
- d_aigBitblaster.reset(new AigBitblaster());
-#else
- Unreachable();
-#endif
- } else {
- d_bitblaster.reset(new EagerBitblaster(d_bv, d_context));
- }
-}
-
-bool EagerBitblastSolver::isInitialized() {
- const bool init = d_aigBitblaster != nullptr || d_bitblaster != nullptr;
- Assert(!init || !d_useAig || d_aigBitblaster);
- Assert(!init || d_useAig || d_bitblaster);
- return init;
-}
-
-void EagerBitblastSolver::assertFormula(TNode formula) {
- d_bv->spendResource(Resource::BvEagerAssertStep);
- Assert(isInitialized());
- Debug("bitvector-eager") << "EagerBitblastSolver::assertFormula " << formula
- << "\n";
- if (options::incrementalSolving() && d_context->getLevel() > 1)
- {
- d_assumptionSet.insert(formula);
- }
- d_assertionSet.insert(formula);
- // ensures all atoms are bit-blasted and converted to AIG
- if (d_useAig) {
-#ifdef CVC5_USE_ABC
- d_aigBitblaster->bbFormula(formula);
-#else
- Unreachable();
-#endif
- }
- else
- {
- d_bitblaster->bbFormula(formula);
- }
-}
-
-bool EagerBitblastSolver::checkSat() {
- Assert(isInitialized());
- if (d_assertionSet.empty()) {
- return true;
- }
-
- if (d_useAig) {
-#ifdef CVC5_USE_ABC
- const std::vector<Node> assertions = {d_assertionSet.key_begin(),
- d_assertionSet.key_end()};
- Assert(!assertions.empty());
-
- Node query = utils::mkAnd(assertions);
- return d_aigBitblaster->solve(query);
-#else
- Unreachable();
-#endif
- }
-
- if (options::incrementalSolving())
- {
- const std::vector<Node> assumptions = {d_assumptionSet.key_begin(),
- d_assumptionSet.key_end()};
- return d_bitblaster->solve(assumptions);
- }
- return d_bitblaster->solve();
-}
-
-bool EagerBitblastSolver::collectModelInfo(TheoryModel* m, bool fullModel)
-{
- AlwaysAssert(!d_useAig && d_bitblaster);
- return d_bitblaster->collectModelInfo(m, fullModel);
-}
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Mathias Preiner, Tim King
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Eager bit-blasting solver.
- */
-
-#include "cvc5_private.h"
-
-#ifndef CVC5__THEORY__BV__BV_EAGER_SOLVER_H
-#define CVC5__THEORY__BV__BV_EAGER_SOLVER_H
-
-#include "expr/node.h"
-#include "theory/bv/bv_solver_layered.h"
-#include "theory/theory_model.h"
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-class EagerBitblaster;
-class AigBitblaster;
-
-/**
- * BitblastSolver
- */
-class EagerBitblastSolver {
- public:
- EagerBitblastSolver(context::Context* c, theory::bv::BVSolverLayered* bv);
- ~EagerBitblastSolver();
- bool checkSat();
- void assertFormula(TNode formula);
-
- void turnOffAig();
- bool isInitialized();
- void initialize();
- bool collectModelInfo(theory::TheoryModel* m, bool fullModel);
-
- private:
- context::CDHashSet<Node> d_assertionSet;
- context::CDHashSet<Node> d_assumptionSet;
- context::Context* d_context;
-
- /** Bitblasters */
- std::unique_ptr<EagerBitblaster> d_bitblaster;
- std::unique_ptr<AigBitblaster> d_aigBitblaster;
- bool d_useAig;
-
- BVSolverLayered* d_bv;
-}; // class EagerBitblastSolver
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
-
-#endif // CVC5__THEORY__BV__BV_EAGER_SOLVER_H
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Aina Niemetz, Mathias Preiner
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * A graph representation of the currently asserted bv inequalities.
- */
-
-#include "theory/bv/bv_inequality_graph.h"
-#include "theory/bv/theory_bv_utils.h"
-
-using namespace std;
-using namespace cvc5;
-using namespace cvc5::context;
-using namespace cvc5::theory;
-using namespace cvc5::theory::bv;
-using namespace cvc5::theory::bv::utils;
-
-const TermId cvc5::theory::bv::UndefinedTermId = -1;
-const ReasonId cvc5::theory::bv::UndefinedReasonId = -1;
-const ReasonId cvc5::theory::bv::AxiomReasonId = -2;
-
-bool InequalityGraph::addInequality(TNode a, TNode b, bool strict, TNode reason) {
- Debug("bv-inequality") << "InequalityGraph::addInequality " << a << " " << b << " strict: " << strict << "\n";
-
- TermId id_a = registerTerm(a);
- TermId id_b = registerTerm(b);
- ReasonId id_reason = registerReason(reason);
-
- Assert(!(isConst(id_a) && isConst(id_b)));
- BitVector a_val = getValue(id_a);
- BitVector b_val = getValue(id_b);
-
- unsigned bitwidth = utils::getSize(a);
- BitVector diff = strict ? BitVector(bitwidth, 1u) : BitVector(bitwidth, 0u);
-
- if (a_val + diff < a_val) {
- // we have an overflow
- std::vector<ReasonId> conflict;
- conflict.push_back(id_reason);
- computeExplanation(UndefinedTermId, id_a, conflict);
- setConflict(conflict);
- return false;
- }
-
- if (a_val + diff <= b_val) {
- // the inequality is true in the current partial model
- // we still add the edge because it may not be true later (cardinality)
- addEdge(id_a, id_b, strict, id_reason);
- return true;
- }
-
- if (isConst(id_b) && a_val + diff > b_val) {
- // we must be in a conflict since a has the minimum value that
- // satisifes the constraints
- std::vector<ReasonId> conflict;
- conflict.push_back(id_reason);
- computeExplanation(UndefinedTermId, id_a, conflict);
- Debug("bv-inequality") << "InequalityGraph::addInequality conflict: constant UB \n";
- setConflict(conflict);
- return false;
- }
-
- // add the inequality edge
- addEdge(id_a, id_b, strict, id_reason);
- BFSQueue queue(&d_modelValues);
- Assert(hasModelValue(id_a));
- queue.push(id_a);
- return processQueue(queue, id_a);
-}
-
-bool InequalityGraph::updateValue(TermId id, ModelValue new_mv, TermId start, bool& changed) {
- BitVector lower_bound = new_mv.value;
-
- if (isConst(id)) {
- if (getValue(id) < lower_bound) {
- Debug("bv-inequality") << "Conflict: constant " << getValue(id) << "\n";
- std::vector<ReasonId> conflict;
- TermId parent = new_mv.parent;
- ReasonId reason = new_mv.reason;
- conflict.push_back(reason);
- computeExplanation(UndefinedTermId, parent, conflict);
- Debug("bv-inequality") << "InequalityGraph::addInequality conflict: constant\n";
- setConflict(conflict);
- return false;
- }
- } else {
- // if not constant we can try to update the value
- if (getValue(id) < lower_bound) {
- // if we are updating the term we started with we must be in a cycle
- if (id == start) {
- TermId parent = new_mv.parent;
- ReasonId reason = new_mv.reason;
- std::vector<TermId> conflict;
- conflict.push_back(reason);
- computeExplanation(id, parent, conflict);
- Debug("bv-inequality") << "InequalityGraph::addInequality conflict: cycle \n";
- setConflict(conflict);
- return false;
- }
- Debug("bv-inequality-internal") << "Updating " << getTermNode(id)
- << " from " << getValue(id) << "\n"
- << " to " << lower_bound << "\n";
- changed = true;
- setModelValue(id, new_mv);
- }
- }
- return true;
-}
-
-bool InequalityGraph::processQueue(BFSQueue& queue, TermId start) {
- while (!queue.empty()) {
- TermId current = queue.top();
- queue.pop();
- Debug("bv-inequality-internal") << "InequalityGraph::processQueue processing " << getTermNode(current) << "\n";
-
- BitVector current_value = getValue(current);
-
- unsigned size = getBitwidth(current);
- const BitVector zero(size, 0u);
- const BitVector one(size, 1u);
-
- const Edges& edges = getEdges(current);
- for (Edges::const_iterator it = edges.begin(); it!= edges.end(); ++it) {
- TermId next = it->next;
- ReasonId reason = it->reason;
-
- const BitVector increment = it->strict ? one : zero;
- const BitVector next_lower_bound = current_value + increment;
-
- if (next_lower_bound < current_value) {
- // it means we have an overflow and hence a conflict
- std::vector<TermId> conflict;
- conflict.push_back(it->reason);
- Assert(hasModelValue(start));
- ReasonId start_reason = getModelValue(start).reason;
- if (start_reason != UndefinedReasonId) {
- conflict.push_back(start_reason);
- }
- computeExplanation(UndefinedTermId, current, conflict);
- Debug("bv-inequality") << "InequalityGraph::addInequality conflict: cycle \n";
- setConflict(conflict);
- return false;
- }
-
- ModelValue new_mv(next_lower_bound, current, reason);
- bool updated = false;
- if (!updateValue(next, new_mv, start, updated)) {
- return false;
- }
-
- if (next == start) {
- // we know what we didn't update start or we would have had a conflict
- // this means we are in a cycle where all the values are forced to be equal
- Debug("bv-inequality-internal") << "InequalityGraph::processQueue equal cycle.";
- continue;
- }
-
- if (!updated) {
- // if we didn't update current we don't need to add to the queue it's children
- Debug("bv-inequality-internal") << " unchanged " << getTermNode(next) << "\n";
- continue;
- }
-
- queue.push(next);
- Debug("bv-inequality-internal") << " enqueue " << getTermNode(next) << "\n";
- }
- }
- return true;
-}
-
-void InequalityGraph::computeExplanation(TermId from, TermId to, std::vector<ReasonId>& explanation) {
- if(Debug.isOn("bv-inequality")) {
- if (from == UndefinedTermId) {
- Debug("bv-inequality") << "InequalityGraph::computeExplanation " << getTermNode(to) << "\n";
- } else {
- Debug("bv-inequality") << "InequalityGraph::computeExplanation " << getTermNode(from) <<" => "
- << getTermNode(to) << "\n";
- }
- }
-
- TermIdSet seen;
-
- while(hasReason(to) && from != to && !seen.count(to)) {
- seen.insert(to);
- const ModelValue& exp = getModelValue(to);
- Assert(exp.reason != UndefinedReasonId);
- explanation.push_back(exp.reason);
- Assert(exp.parent != UndefinedTermId);
- to = exp.parent;
- Debug("bv-inequality-internal") << " parent: " << getTermNode(to) << "\n"
- << " reason: " << getReasonNode(exp.reason) << "\n";
- }
-}
-
-void InequalityGraph::addEdge(TermId a, TermId b, bool strict, TermId reason) {
- Debug("bv-inequality-internal") << "InequalityGraph::addEdge " << getTermNode(a) << " => " << getTermNode(b) << "\n"
- << " strict ? " << strict << "\n";
- Edges& edges = getEdges(a);
- InequalityEdge new_edge(b, strict, reason);
- edges.push_back(new_edge);
- d_undoStack.push_back(std::make_pair(a, new_edge));
- d_undoStackIndex = d_undoStackIndex + 1;
-}
-
-void InequalityGraph::initializeModelValue(TNode node) {
- TermId id = getTermId(node);
- Assert(!hasModelValue(id));
- bool isConst = node.getKind() == kind::CONST_BITVECTOR;
- unsigned size = utils::getSize(node);
- BitVector value = isConst? node.getConst<BitVector>() : BitVector(size, 0u);
- setModelValue(id, ModelValue(value, UndefinedTermId, UndefinedReasonId));
-}
-
-bool InequalityGraph::isRegistered(TNode term) const {
- return d_termNodeToIdMap.find(term) != d_termNodeToIdMap.end();
-}
-
-TermId InequalityGraph::registerTerm(TNode term) {
- if (d_termNodeToIdMap.find(term) != d_termNodeToIdMap.end()) {
- TermId id = d_termNodeToIdMap[term];
- if (!hasModelValue(id)) {
- // we could have backtracked and
- initializeModelValue(term);
- }
- return id;
- }
-
- // store in node mapping
- TermId id = d_termNodes.size();
- Debug("bv-inequality-internal") << "InequalityGraph::registerTerm " << term << " => id"<< id << "\n";
-
- d_termNodes.push_back(term);
- d_termNodeToIdMap[term] = id;
-
- // create InequalityNode
- unsigned size = utils::getSize(term);
-
- bool isConst = term.getKind() == kind::CONST_BITVECTOR;
- InequalityNode ineq = InequalityNode(id, size, isConst);
-
- Assert(d_ineqNodes.size() == id);
- d_ineqNodes.push_back(ineq);
-
- Assert(d_ineqEdges.size() == id);
- d_ineqEdges.push_back(Edges());
-
- initializeModelValue(term);
-
- return id;
-}
-
-ReasonId InequalityGraph::registerReason(TNode reason) {
- if (d_reasonToIdMap.find(reason) != d_reasonToIdMap.end()) {
- return d_reasonToIdMap[reason];
- }
- d_reasonSet.insert(reason);
- ReasonId id = d_reasonNodes.size();
- d_reasonNodes.push_back(reason);
- d_reasonToIdMap[reason] = id;
- Debug("bv-inequality-internal") << "InequalityGraph::registerReason " << reason << " => id"<< id << "\n";
- return id;
-}
-
-TNode InequalityGraph::getReasonNode(ReasonId id) const {
- Assert(d_reasonNodes.size() > id);
- return d_reasonNodes[id];
-}
-
-TNode InequalityGraph::getTermNode(TermId id) const {
- Assert(d_termNodes.size() > id);
- return d_termNodes[id];
-}
-
-TermId InequalityGraph::getTermId(TNode node) const {
- Assert(d_termNodeToIdMap.find(node) != d_termNodeToIdMap.end());
- return d_termNodeToIdMap.find(node)->second;
-}
-
-void InequalityGraph::setConflict(const std::vector<ReasonId>& conflict) {
- Assert(!d_inConflict);
- d_inConflict = true;
- d_conflict.clear();
- for (unsigned i = 0; i < conflict.size(); ++i) {
- if (conflict[i] != AxiomReasonId) {
- d_conflict.push_back(getReasonNode(conflict[i]));
- }
- }
- if (Debug.isOn("bv-inequality")) {
- Debug("bv-inequality") << "InequalityGraph::setConflict \n";
- for (unsigned i = 0; i < d_conflict.size(); ++i) {
- Debug("bv-inequality") << " " << d_conflict[i] <<"\n";
- }
- }
-}
-
-void InequalityGraph::getConflict(std::vector<TNode>& conflict) {
- for (unsigned i = 0; i < d_conflict.size(); ++i) {
- conflict.push_back(d_conflict[i]);
- }
-}
-
-void InequalityGraph::setModelValue(TermId term, const ModelValue& mv) {
- d_modelValues[term] = mv;
-}
-
-InequalityGraph::ModelValue InequalityGraph::getModelValue(TermId term) const {
- Assert(d_modelValues.find(term) != d_modelValues.end());
- return (*(d_modelValues.find(term))).second;
-}
-
-bool InequalityGraph::hasModelValue(TermId id) const {
- return d_modelValues.find(id) != d_modelValues.end();
-}
-
-BitVector InequalityGraph::getValue(TermId id) const {
- Assert(hasModelValue(id));
- return (*(d_modelValues.find(id))).second.value;
-}
-
-bool InequalityGraph::hasReason(TermId id) const {
- const ModelValue& mv = getModelValue(id);
- return mv.reason != UndefinedReasonId;
-}
-
-bool InequalityGraph::addDisequality(TNode a, TNode b, TNode reason) {
- Debug("bv-inequality") << "InequalityGraph::addDisequality " << reason << "\n";
- d_disequalities.push_back(reason);
-
- if (!isRegistered(a) || !isRegistered(b)) {
- //splitDisequality(reason);
- return true;
- }
- TermId id_a = getTermId(a);
- TermId id_b = getTermId(b);
- if (!hasModelValue(id_a)) {
- initializeModelValue(a);
- }
- if (!hasModelValue(id_b)) {
- initializeModelValue(b);
- }
- const BitVector val_a = getValue(id_a);
- const BitVector val_b = getValue(id_b);
- if (val_a == val_b) {
- if (a.getKind() == kind::CONST_BITVECTOR) {
- // then we know b cannot be smaller than the assigned value so we try to make it larger
- std::vector<ReasonId> explanation_ids;
- computeExplanation(UndefinedTermId, id_b, explanation_ids);
- std::vector<TNode> explanation_nodes;
- explanation_nodes.push_back(reason);
- for (unsigned i = 0; i < explanation_ids.size(); ++i) {
- explanation_nodes.push_back(getReasonNode(explanation_ids[i]));
- }
- Node explanation = utils::mkAnd(explanation_nodes);
- d_reasonSet.insert(explanation);
- return addInequality(a, b, true, explanation);
- }
- if (b.getKind() == kind::CONST_BITVECTOR) {
- // then we know b cannot be smaller than the assigned value so we try to make it larger
- std::vector<ReasonId> explanation_ids;
- computeExplanation(UndefinedTermId, id_a, explanation_ids);
- std::vector<TNode> explanation_nodes;
- explanation_nodes.push_back(reason);
- for (unsigned i = 0; i < explanation_ids.size(); ++i) {
- explanation_nodes.push_back(getReasonNode(explanation_ids[i]));
- }
- Node explanation = utils::mkAnd(explanation_nodes);
- d_reasonSet.insert(explanation);
- return addInequality(b, a, true, explanation);
- }
- // if none of the terms are constants just add the lemma
- //splitDisequality(reason);
- } else {
- Debug("bv-inequality-internal") << "Disequal: " << a << " => " << val_a.toString(10) << "\n"
- << " " << b << " => " << val_b.toString(10) << "\n";
- }
- return true;
-}
-
-// void InequalityGraph::splitDisequality(TNode diseq) {
-// Debug("bv-inequality-internal")<<"InequalityGraph::splitDisequality " <<
-// diseq <<"\n"; Assert (diseq.getKind() == kind::NOT &&
-// diseq[0].getKind() == kind::EQUAL); if
-// (d_disequalitiesAlreadySplit.find(diseq) ==
-// d_disequalitiesAlreadySplit.end()) {
-// d_disequalitiesToSplit.push_back(diseq);
-// }
-// }
-
-void InequalityGraph::backtrack() {
- Debug("bv-inequality-internal") << "InequalityGraph::backtrack()\n";
- int size = d_undoStack.size();
- for (int i = size - 1; i >= (int)d_undoStackIndex.get(); --i) {
- Assert(!d_undoStack.empty());
- TermId id = d_undoStack.back().first;
- InequalityEdge edge = d_undoStack.back().second;
- d_undoStack.pop_back();
-
- Debug("bv-inequality-internal") << " remove edge " << getTermNode(id) << " => "
- << getTermNode(edge.next) <<"\n";
- Edges& edges = getEdges(id);
- for (Edges::const_iterator it = edges.begin(); it!= edges.end(); ++it) {
- Debug("bv-inequality-internal") << getTermNode(it->next) <<" " << it->strict << "\n";
- }
- Assert(!edges.empty());
- Assert(edges.back() == edge);
- edges.pop_back();
- }
-}
-
-Node InequalityGraph::makeDiseqSplitLemma(TNode diseq)
-{
- Assert(diseq.getKind() == kind::NOT && diseq[0].getKind() == kind::EQUAL);
- NodeManager* nm = NodeManager::currentNM();
- TNode a = diseq[0][0];
- TNode b = diseq[0][1];
- Node a_lt_b = nm->mkNode(kind::BITVECTOR_ULT, a, b);
- Node b_lt_a = nm->mkNode(kind::BITVECTOR_ULT, b, a);
- Node eq = diseq[0];
- Node lemma = nm->mkNode(kind::OR, a_lt_b, b_lt_a, eq);
- return lemma;
-}
-
-void InequalityGraph::checkDisequalities(std::vector<Node>& lemmas) {
- for (CDQueue<TNode>::const_iterator it = d_disequalities.begin(); it != d_disequalities.end(); ++it) {
- if (d_disequalitiesAlreadySplit.find(*it) == d_disequalitiesAlreadySplit.end()) {
- // if we haven't already split on this disequality
- TNode diseq = *it;
- TermId a_id = registerTerm(diseq[0][0]);
- TermId b_id = registerTerm(diseq[0][1]);
- if (getValue(a_id) == getValue(b_id)) {
- lemmas.push_back(makeDiseqSplitLemma(diseq));
- d_disequalitiesAlreadySplit.insert(diseq);
- }
- }
- }
-}
-
-bool InequalityGraph::isLessThan(TNode a, TNode b) {
- Assert(isRegistered(a) && isRegistered(b));
- Unimplemented();
-}
-
-bool InequalityGraph::hasValueInModel(TNode node) const {
- if (isRegistered(node)) {
- TermId id = getTermId(node);
- return hasModelValue(id);
- }
- return false;
-}
-
-BitVector InequalityGraph::getValueInModel(TNode node) const {
- TermId id = getTermId(node);
- Assert(hasModelValue(id));
- return getValue(id);
-}
-
-void InequalityGraph::getAllValuesInModel(std::vector<Node>& assignments)
-{
- NodeManager* nm = NodeManager::currentNM();
- for (ModelValues::const_iterator it = d_modelValues.begin();
- it != d_modelValues.end();
- ++it)
- {
- TermId id = (*it).first;
- BitVector value = (*it).second.value;
- TNode var = getTermNode(id);
- Node constant = utils::mkConst(value);
- Node assignment = nm->mkNode(kind::EQUAL, var, constant);
- assignments.push_back(assignment);
- Debug("bitvector-model") << " " << var << " => " << constant << "\n";
- }
-}
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Mathias Preiner, Tim King
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Algebraic solver.
- */
-
-#include "cvc5_private.h"
-
-#ifndef CVC5__THEORY__BV__BV_INEQUALITY__GRAPH_H
-#define CVC5__THEORY__BV__BV_INEQUALITY__GRAPH_H
-
-#include <queue>
-#include <unordered_map>
-#include <unordered_set>
-
-#include "context/cdhashmap.h"
-#include "context/cdhashset.h"
-#include "context/cdo.h"
-#include "context/cdqueue.h"
-#include "context/context.h"
-#include "util/bitvector.h"
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-typedef unsigned TermId;
-typedef unsigned ReasonId;
-extern const TermId UndefinedTermId;
-extern const ReasonId UndefinedReasonId;
-extern const ReasonId AxiomReasonId;
-
-class InequalityGraph : public context::ContextNotifyObj{
-
- struct InequalityEdge {
- TermId next;
- ReasonId reason;
- bool strict;
- InequalityEdge(TermId n, bool s, ReasonId r)
- : next(n),
- reason(r),
- strict(s)
- {}
- bool operator==(const InequalityEdge& other) const {
- return next == other.next && reason == other.reason && strict == other.strict;
- }
- };
-
- class InequalityNode {
- TermId d_id;
- unsigned d_bitwidth;
- bool d_isConstant;
- public:
- InequalityNode(TermId id, unsigned bitwidth, bool isConst)
- : d_id(id),
- d_bitwidth(bitwidth),
- d_isConstant(isConst)
- {}
- TermId getId() const { return d_id; }
- unsigned getBitwidth() const { return d_bitwidth; }
- bool isConstant() const { return d_isConstant; }
- };
-
- struct ModelValue {
- TermId parent;
- ReasonId reason;
- BitVector value;
- ModelValue()
- : parent(UndefinedTermId),
- reason(UndefinedReasonId),
- value(0, 0u)
- {}
-
- ModelValue(const BitVector& val, TermId p, ReasonId r)
- : parent(p),
- reason(r),
- value(val)
- {}
- };
-
- typedef context::CDHashMap<TermId, ModelValue> ModelValues;
-
- struct QueueComparator {
- const ModelValues* d_model;
- QueueComparator(const ModelValues* model)
- : d_model(model)
- {}
- bool operator() (TermId left, TermId right) const {
- Assert(d_model->find(left) != d_model->end()
- && d_model->find(right) != d_model->end());
-
- return (*(d_model->find(left))).second.value < (*(d_model->find(right))).second.value;
- }
- };
-
- typedef std::unordered_map<TNode, ReasonId> ReasonToIdMap;
- typedef std::unordered_map<TNode, TermId> TermNodeToIdMap;
-
- typedef std::vector<InequalityEdge> Edges;
- typedef std::unordered_set<TermId> TermIdSet;
-
- typedef std::priority_queue<TermId, std::vector<TermId>, QueueComparator>
- BFSQueue;
- typedef std::unordered_set<TNode> TNodeSet;
- typedef std::unordered_set<Node> NodeSet;
-
- std::vector<InequalityNode> d_ineqNodes;
- std::vector< Edges > d_ineqEdges;
-
- // to keep the explanation nodes alive
- NodeSet d_reasonSet;
- std::vector<TNode> d_reasonNodes;
- ReasonToIdMap d_reasonToIdMap;
-
- std::vector<Node> d_termNodes;
- TermNodeToIdMap d_termNodeToIdMap;
-
- context::CDO<bool> d_inConflict;
- std::vector<TNode> d_conflict;
-
- ModelValues d_modelValues;
- void initializeModelValue(TNode node);
- void setModelValue(TermId term, const ModelValue& mv);
- ModelValue getModelValue(TermId term) const;
- bool hasModelValue(TermId id) const;
- bool hasReason(TermId id) const;
-
- /**
- * Registers the term by creating its corresponding InequalityNode
- * and adding the min <= term <= max default edges.
- *
- * @param term
- *
- * @return
- */
- TermId registerTerm(TNode term);
- TNode getTermNode(TermId id) const;
- TermId getTermId(TNode node) const;
- bool isRegistered(TNode term) const;
-
- ReasonId registerReason(TNode reason);
- TNode getReasonNode(ReasonId id) const;
-
- Edges& getEdges(TermId id)
- {
- Assert(id < d_ineqEdges.size());
- return d_ineqEdges[id];
- }
- InequalityNode& getInequalityNode(TermId id)
- {
- Assert(id < d_ineqNodes.size());
- return d_ineqNodes[id];
- }
- const InequalityNode& getInequalityNode(TermId id) const
- {
- Assert(id < d_ineqNodes.size());
- return d_ineqNodes[id];
- }
- unsigned getBitwidth(TermId id) const { return getInequalityNode(id).getBitwidth(); }
- bool isConst(TermId id) const { return getInequalityNode(id).isConstant(); }
-
- BitVector getValue(TermId id) const;
-
- void addEdge(TermId a, TermId b, bool strict, TermId reason);
-
- void setConflict(const std::vector<ReasonId>& conflict);
- /**
- * If necessary update the value in the model of the current queue element.
- *
- * @param id current queue element we are updating
- * @param start node we started with, to detect cycles
- *
- * @return
- */
- bool updateValue(TermId id, ModelValue new_mv, TermId start, bool& changed);
- /**
- * Update the current model starting with the start term.
- *
- * @param queue
- * @param start
- *
- * @return
- */
- bool processQueue(BFSQueue& queue, TermId start);
- /**
- * Return the reasons why from <= to. If from is undefined we just
- * explain the current value of to.
- *
- * @param from
- * @param to
- * @param explanation
- */
- void computeExplanation(TermId from, TermId to, std::vector<ReasonId>& explanation);
- // void splitDisequality(TNode diseq);
-
- /**
- Disequality reasoning
- */
-
- /*** The currently asserted disequalities */
- context::CDQueue<TNode> d_disequalities;
- typedef context::CDHashSet<Node> CDNodeSet;
- CDNodeSet d_disequalitiesAlreadySplit;
- Node makeDiseqSplitLemma(TNode diseq);
- /** Backtracking mechanisms **/
- std::vector<std::pair<TermId, InequalityEdge> > d_undoStack;
- context::CDO<unsigned> d_undoStackIndex;
-
- void contextNotifyPop() override { backtrack(); }
-
- void backtrack();
-
-public:
-
- InequalityGraph(context::Context* c, context::Context* u, bool s = false)
- : ContextNotifyObj(c),
- d_ineqNodes(),
- d_ineqEdges(),
- d_inConflict(c, false),
- d_conflict(),
- d_modelValues(c),
- d_disequalities(c),
- d_disequalitiesAlreadySplit(u),
- d_undoStack(),
- d_undoStackIndex(c)
- {}
- /**
- * Add a new inequality to the graph
- *
- * @param a
- * @param b
- * @param strict
- * @param reason
- *
- * @return
- */
- bool addInequality(TNode a, TNode b, bool strict, TNode reason);
- /**
- * Add a new disequality to the graph. This may lead in a lemma.
- *
- * @param a
- * @param b
- * @param reason
- *
- * @return
- */
- bool addDisequality(TNode a, TNode b, TNode reason);
- void getConflict(std::vector<TNode>& conflict);
- virtual ~InequalityGraph() {}
- /**
- * Check that the currently asserted disequalities that have not been split on
- * are still true in the current model.
- */
- void checkDisequalities(std::vector<Node>& lemmas);
- /**
- * Return true if a < b is entailed by the current set of assertions.
- *
- * @param a
- * @param b
- *
- * @return
- */
- bool isLessThan(TNode a, TNode b);
- /**
- * Returns true if the term has a value in the model (i.e. if we have seen it)
- *
- * @param a
- *
- * @return
- */
- bool hasValueInModel(TNode a) const;
- /**
- * Return the value of a in the current model.
- *
- * @param a
- *
- * @return
- */
- BitVector getValueInModel(TNode a) const;
-
- void getAllValuesInModel(std::vector<Node>& assignments);
-};
-
-}
-}
-} // namespace cvc5
-
-#endif /* CVC5__THEORY__BV__BV_INEQUALITY__GRAPH_H */
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Tim King, Mathias Preiner
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Wrapper around the SAT solver used for bitblasting.
- */
-
-#include "theory/bv/bv_quick_check.h"
-
-#include "smt/smt_statistics_registry.h"
-#include "theory/bv/bitblast/lazy_bitblaster.h"
-#include "theory/bv/bv_solver_layered.h"
-#include "theory/bv/theory_bv_utils.h"
-
-using namespace cvc5::prop;
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-BVQuickCheck::BVQuickCheck(const std::string& name,
- theory::bv::BVSolverLayered* bv)
- : d_ctx(),
- d_bitblaster(new TLazyBitblaster(&d_ctx, bv, name, true)),
- d_conflict(),
- d_inConflict(&d_ctx, false)
-{}
-
-
-bool BVQuickCheck::inConflict() { return d_inConflict.get(); }
-
-uint64_t BVQuickCheck::computeAtomWeight(TNode node, NodeSet& seen) {
- return d_bitblaster->computeAtomWeight(node, seen);
-}
-
-void BVQuickCheck::setConflict()
-{
- Assert(!inConflict());
- std::vector<TNode> conflict;
- d_bitblaster->getConflict(conflict);
- Node confl = utils::mkAnd(conflict);
- d_inConflict = true;
- d_conflict = confl;
-}
-
-prop::SatValue BVQuickCheck::checkSat(std::vector<Node>& assumptions, unsigned long budget) {
- Node conflict;
-
- for (unsigned i = 0; i < assumptions.size(); ++i) {
- TNode a = assumptions[i];
- Assert(a.getType().isBoolean());
- d_bitblaster->bbAtom(a);
- bool ok = d_bitblaster->assertToSat(a, false);
- if (!ok) {
- setConflict();
- return SAT_VALUE_FALSE;
- }
- }
-
- if (budget == 0) {
- bool ok = d_bitblaster->propagate();
- if (!ok) {
- setConflict();
- return SAT_VALUE_FALSE;
- }
- return SAT_VALUE_UNKNOWN; // could check if assignment is full and return SAT_VALUE_TRUE
- }
-
- prop::SatValue res = d_bitblaster->solveWithBudget(budget);
- if (res == SAT_VALUE_FALSE) {
- setConflict();
- return res;
- }
- // could be unknown or could be sat
- return res;
-}
-
-prop::SatValue BVQuickCheck::checkSat(unsigned long budget) {
- prop::SatValue res = d_bitblaster->solveWithBudget(budget);
- if (res == SAT_VALUE_FALSE) {
- setConflict();
- }
- return res;
-}
-
-bool BVQuickCheck::addAssertion(TNode assertion) {
- Assert(assertion.getType().isBoolean());
- d_bitblaster->bbAtom(assertion);
- // assert to sat solver and run bcp to detect easy conflicts
- bool ok = d_bitblaster->assertToSat(assertion, true);
- if (!ok) {
- setConflict();
- }
- return ok;
-}
-
-
-void BVQuickCheck::push() {
- d_ctx.push();
-}
-
-void BVQuickCheck::pop() {
- d_ctx.pop();
-}
-
-BVQuickCheck::vars_iterator BVQuickCheck::beginVars() {
- return d_bitblaster->beginVars();
-}
-BVQuickCheck::vars_iterator BVQuickCheck::endVars() {
- return d_bitblaster->endVars();
-}
-
-Node BVQuickCheck::getVarValue(TNode var, bool fullModel) {
- return d_bitblaster->getTermModel(var, fullModel);
-}
-
-
-/**
- * Constructs a new sat solver which requires throwing out the atomBBCache
- * but keeps all the termBBCache
- *
- */
-void BVQuickCheck::clearSolver() {
- popToZero();
- d_bitblaster->clearSolver();
-}
-
-void BVQuickCheck::popToZero() {
- while (d_ctx.getLevel() > 0) {
- d_ctx.pop();
- }
-}
-
-bool BVQuickCheck::collectModelValues(theory::TheoryModel* model,
- const std::set<Node>& termSet)
-{
- return d_bitblaster->collectModelValues(model, termSet);
-}
-
-BVQuickCheck::~BVQuickCheck() {
- clearSolver();
-}
-
-QuickXPlain::QuickXPlain(const std::string& name, BVQuickCheck* solver, unsigned long budget)
- : d_solver(solver)
- , d_budget(budget)
- , d_numCalled(0)
- , d_minRatioSum(0)
- , d_numConflicts(0)
- // , d_period(20)
- // , d_thresh(0.7)
- // , d_hardThresh(0.9)
- , d_statistics(name)
-{}
-QuickXPlain::~QuickXPlain() {}
-
-unsigned QuickXPlain::selectUnsatCore(unsigned low, unsigned high,
- std::vector<TNode>& conflict) {
- Assert(!d_solver->getConflict().isNull() && d_solver->inConflict());
- Node query_confl = d_solver->getConflict();
-
- // conflict wasn't actually minimized
- if (query_confl.getNumChildren() == high - low + 1) {
- return high;
- }
-
- TNodeSet nodes;
- for (unsigned i = low; i <= high; i++) {
- nodes.insert(conflict[i]);
- }
-
- unsigned write = low;
- for (unsigned i = 0; i < query_confl.getNumChildren(); ++i) {
- TNode current = query_confl[i];
- // the conflict can have nodes in lower decision levels
- if (nodes.find(current) != nodes.end()) {
- conflict[write++] = current;
- nodes.erase(nodes.find(current));
- }
- }
- // if all of the nodes in the conflict were on a lower level
- if (write == low) {
- return low;
- }
- Assert(write != 0);
- unsigned new_high = write - 1;
-
- for (TNodeSet::const_iterator it = nodes.begin(); it != nodes.end(); ++it) {
- conflict[write++] = *it;
- }
- Assert(write - 1 == high);
- Assert(new_high <= high);
-
- return new_high;
-}
-
-void QuickXPlain::minimizeConflictInternal(unsigned low, unsigned high,
- std::vector<TNode>& conflict,
- std::vector<TNode>& new_conflict) {
- Assert(low <= high && high < conflict.size());
-
- if (low == high) {
- new_conflict.push_back(conflict[low]);
- return;
- }
-
- // check if top half is unsat
- unsigned new_low = (high - low + 1)/ 2 + low;
- d_solver->push();
-
- for (unsigned i = new_low; i <=high; ++i) {
- bool ok = d_solver->addAssertion(conflict[i]);
- if (!ok) {
- unsigned top = selectUnsatCore(new_low, i, conflict);
- d_solver->pop();
- minimizeConflictInternal(new_low, top, conflict, new_conflict);
- return;
- }
- }
-
- SatValue res = d_solver->checkSat(d_budget);
-
- if (res == SAT_VALUE_UNKNOWN) {
- ++(d_statistics.d_numUnknown);
- } else {
- ++(d_statistics.d_numSolved);
- }
-
- if (res == SAT_VALUE_FALSE) {
- unsigned top = selectUnsatCore(new_low, high, conflict);
- d_solver->pop();
- minimizeConflictInternal(new_low, top, conflict, new_conflict);
- return;
- }
-
- d_solver->pop();
- unsigned new_high = new_low - 1;
- d_solver->push();
-
- // check bottom half
- for (unsigned i = low; i <= new_high; ++i) {
- bool ok = d_solver->addAssertion(conflict[i]);
- if (!ok) {
- unsigned top = selectUnsatCore(low, i, conflict);
- d_solver->pop();
- minimizeConflictInternal(low, top, conflict, new_conflict);
- return;
- }
- }
-
- res = d_solver->checkSat(d_budget);
-
- if (res == SAT_VALUE_UNKNOWN) {
- ++(d_statistics.d_numUnknown);
- } else {
- ++(d_statistics.d_numSolved);
- }
-
- if (res == SAT_VALUE_FALSE) {
- unsigned top = selectUnsatCore(low, new_high, conflict);
- d_solver->pop();
- minimizeConflictInternal(low, top, conflict, new_conflict);
- return;
- }
-
- // conflict (probably) contains literals in both halves
- // keep bottom half in context (no pop)
- minimizeConflictInternal(new_low, high, conflict, new_conflict);
- d_solver->pop();
- d_solver->push();
- for (unsigned i = 0; i < new_conflict.size(); ++i) {
- bool ok = d_solver->addAssertion(new_conflict[i]);
- if (!ok) {
- ++(d_statistics.d_numUnknownWasUnsat);
- d_solver->pop();
- return;
- }
- }
- minimizeConflictInternal(low, new_high, conflict, new_conflict);
- d_solver->pop();
-}
-
-
-bool QuickXPlain::useHeuristic() {
- return true;
- // d_statistics.d_finalPeriod.setData(d_period);
- // // try to minimize conflict periodically
- // if (d_numConflicts % d_period == 0)
- // return true;
-
- // if (d_numCalled == 0) {
- // return true;
- // }
-
- // if (d_minRatioSum / d_numCalled >= d_thresh &&
- // d_numCalled <= 20 ) {
- // return false;
- // }
-
- // if (d_minRatioSum / d_numCalled >= d_hardThresh) {
- // return false;
- // }
-
- // return true;
-}
-
-Node QuickXPlain::minimizeConflict(TNode confl) {
- ++d_numConflicts;
-
- if (!useHeuristic()) {
- return confl;
- }
-
- ++d_numCalled;
- ++(d_statistics.d_numConflictsMinimized);
- TimerStat::CodeTimer xplainTimer(d_statistics.d_xplainTime);
- Assert(confl.getNumChildren() > 2);
- std::vector<TNode> conflict;
- for (unsigned i = 0; i < confl.getNumChildren(); ++i) {
- conflict.push_back(confl[i]);
- }
- d_solver->popToZero();
- std::vector<TNode> minimized;
- minimizeConflictInternal(0, conflict.size() - 1, conflict, minimized);
-
- double minimization_ratio = ((double) minimized.size())/confl.getNumChildren();
- d_minRatioSum+= minimization_ratio;
-
-
- // if (minimization_ratio >= d_hardThresh) {
- // d_period = d_period * 5;
- // }
-
- // if (minimization_ratio <= d_thresh && d_period >= 40) {
- // d_period = d_period *0.5;
- // }
-
- // if (1.5* d_statistics.d_numUnknown.getData() > d_statistics.d_numSolved.getData()) {
- // d_period = d_period * 2;
- // }
- d_statistics.d_avgMinimizationRatio << minimization_ratio;
- return utils::mkAnd(minimized);
-}
-
-QuickXPlain::Statistics::Statistics(const std::string& name)
- : d_xplainTime(
- smtStatisticsRegistry().registerTimer(name + "QuickXplain::Time")),
- d_numSolved(
- smtStatisticsRegistry().registerInt(name + "QuickXplain::NumSolved")),
- d_numUnknown(smtStatisticsRegistry().registerInt(
- name + "QuickXplain::NumUnknown")),
- d_numUnknownWasUnsat(smtStatisticsRegistry().registerInt(
- name + "QuickXplain::NumUnknownWasUnsat")),
- d_numConflictsMinimized(smtStatisticsRegistry().registerInt(
- name + "QuickXplain::NumConflictsMinimized")),
- d_finalPeriod(smtStatisticsRegistry().registerInt(
- name + "QuickXplain::FinalPeriod")),
- d_avgMinimizationRatio(smtStatisticsRegistry().registerAverage(
- name + "QuickXplain::AvgMinRatio"))
-{
-}
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Mathias Preiner, Morgan Deters
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Sandboxed SAT solver for bv quickchecks.
- */
-
-#include "cvc5_private.h"
-
-#ifndef CVC5__BV_QUICK_CHECK_H
-#define CVC5__BV_QUICK_CHECK_H
-
-#include <unordered_set>
-#include <vector>
-
-#include "context/cdo.h"
-#include "expr/node.h"
-#include "prop/sat_solver_types.h"
-#include "theory/bv/theory_bv_utils.h"
-#include "util/statistics_stats.h"
-
-namespace cvc5 {
-namespace theory {
-
-class TheoryModel;
-
-namespace bv {
-
-class TLazyBitblaster;
-class BVSolverLayered;
-
-class BVQuickCheck
-{
- context::Context d_ctx;
- std::unique_ptr<TLazyBitblaster> d_bitblaster;
- Node d_conflict;
- context::CDO<bool> d_inConflict;
- void setConflict();
-
- public:
- BVQuickCheck(const std::string& name, theory::bv::BVSolverLayered* bv);
- ~BVQuickCheck();
- bool inConflict();
- Node getConflict() { return d_conflict; }
- /**
- * Checks the satisfiability for a given set of assumptions.
- *
- * @param assumptions literals assumed true
- * @param budget max number of conflicts
- *
- * @return
- */
- prop::SatValue checkSat(std::vector<Node>& assumptions, unsigned long budget);
- /**
- * Checks the satisfiability of given assertions.
- *
- * @param budget max number of conflicts
- *
- * @return
- */
- prop::SatValue checkSat(unsigned long budget);
-
- /**
- * Convert to CNF and assert the given literal.
- *
- * @param assumption bv literal
- *
- * @return false if a conflict has been found via bcp.
- */
- bool addAssertion(TNode assumption);
-
- void push();
- void pop();
- void popToZero();
- /**
- * Deletes the SAT solver and CNF stream, but maintains the
- * bit-blasting term cache.
- *
- */
- void clearSolver();
-
- /**
- * Computes the size of the circuit required to bit-blast
- * atom, by not recounting the nodes in seen.
- *
- * @param node
- * @param seen
- *
- * @return
- */
- uint64_t computeAtomWeight(TNode atom, NodeSet& seen);
- bool collectModelValues(theory::TheoryModel* model,
- const std::set<Node>& termSet);
-
- typedef std::unordered_set<TNode>::const_iterator vars_iterator;
- vars_iterator beginVars();
- vars_iterator endVars();
-
- Node getVarValue(TNode var, bool fullModel);
-};
-
-class QuickXPlain
-{
- struct Statistics
- {
- TimerStat d_xplainTime;
- IntStat d_numSolved;
- IntStat d_numUnknown;
- IntStat d_numUnknownWasUnsat;
- IntStat d_numConflictsMinimized;
- IntStat d_finalPeriod;
- AverageStat d_avgMinimizationRatio;
- Statistics(const std::string& name);
- };
- BVQuickCheck* d_solver;
- unsigned long d_budget;
-
- // crazy heuristic variables
- unsigned d_numCalled; // number of times called
- double d_minRatioSum; // sum of minimization ratio for computing average min
- // ratio
- unsigned d_numConflicts; // number of conflicts (including when minimization
- // not applied)
- // unsigned d_period; // after how many conflicts to try minimizing again
-
- // double d_thresh; // if minimization ratio is less, increase period
- // double d_hardThresh; // decrease period if minimization ratio is greater
- // than this
-
- Statistics d_statistics;
- /**
- * Uses solve with assumptions unsat core feature to
- * further minimize a conflict. The minimized conflict
- * will be between low and the returned value in conflict.
- *
- * @param low
- * @param high
- * @param conflict
- *
- * @return
- */
- unsigned selectUnsatCore(unsigned low,
- unsigned high,
- std::vector<TNode>& conflict);
- /**
- * Internal conflict minimization, attempts to minimize
- * literals in conflict between low and high and adds the
- * result in new_conflict.
- *
- * @param low
- * @param high
- * @param conflict
- * @param new_conflict
- */
- void minimizeConflictInternal(unsigned low,
- unsigned high,
- std::vector<TNode>& conflict,
- std::vector<TNode>& new_conflict);
-
- bool useHeuristic();
-
- public:
- QuickXPlain(const std::string& name,
- BVQuickCheck* solver,
- unsigned long budged = 10000);
- ~QuickXPlain();
- Node minimizeConflict(TNode conflict);
-};
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
-
-#endif /* CVC5__BV_QUICK_CHECK_H */
*/
virtual Node getValue(TNode node, bool initialize) { return Node::null(); }
- /** Called by abstraction preprocessing pass. */
- virtual bool applyAbstraction(const std::vector<Node>& assertions,
- std::vector<Node>& new_assertions)
- {
- new_assertions.insert(
- new_assertions.end(), assertions.begin(), assertions.end());
- return false;
- };
-
protected:
TheoryState& d_state;
TheoryInferenceManager& d_im;
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Mathias Preiner, Liana Hadarean, Andrew Reynolds
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Layered bit-vector solver.
- */
-
-#include "theory/bv/bv_solver_layered.h"
-
-#include "expr/node_algorithm.h"
-#include "options/bv_options.h"
-#include "options/smt_options.h"
-#include "smt/smt_statistics_registry.h"
-#include "theory/bv/abstraction.h"
-#include "theory/bv/bv_eager_solver.h"
-#include "theory/bv/bv_subtheory_algebraic.h"
-#include "theory/bv/bv_subtheory_bitblast.h"
-#include "theory/bv/bv_subtheory_core.h"
-#include "theory/bv/bv_subtheory_inequality.h"
-#include "theory/bv/theory_bv_rewrite_rules_normalization.h"
-#include "theory/bv/theory_bv_rewrite_rules_simplification.h"
-#include "theory/bv/theory_bv_rewriter.h"
-#include "theory/bv/theory_bv_utils.h"
-#include "theory/theory_model.h"
-
-using namespace cvc5::theory::bv::utils;
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-BVSolverLayered::BVSolverLayered(Env& env,
- TheoryBV& bv,
- context::Context* c,
- context::UserContext* u,
- ProofNodeManager* pnm,
- std::string name)
- : BVSolver(env, bv.d_state, bv.d_im),
- d_bv(bv),
- d_context(c),
- d_alreadyPropagatedSet(c),
- d_sharedTermsSet(c),
- d_subtheories(),
- d_subtheoryMap(),
- d_statistics(),
- d_lemmasAdded(c, false),
- d_conflict(c, false),
- d_invalidateModelCache(c, true),
- d_literalsToPropagate(c),
- d_literalsToPropagateIndex(c, 0),
- d_propagatedBy(c),
- d_eagerSolver(),
- d_abstractionModule(new AbstractionModule(getStatsPrefix(THEORY_BV))),
- d_calledPreregister(false)
-{
- if (options().bv.bitblastMode == options::BitblastMode::EAGER)
- {
- d_eagerSolver.reset(new EagerBitblastSolver(c, this));
- return;
- }
-
- if (options().bv.bitvectorEqualitySolver)
- {
- d_subtheories.emplace_back(new CoreSolver(c, this));
- d_subtheoryMap[SUB_CORE] = d_subtheories.back().get();
- }
-
- if (options().bv.bitvectorInequalitySolver)
- {
- d_subtheories.emplace_back(new InequalitySolver(c, u, this));
- d_subtheoryMap[SUB_INEQUALITY] = d_subtheories.back().get();
- }
-
- if (options().bv.bitvectorAlgebraicSolver)
- {
- d_subtheories.emplace_back(new AlgebraicSolver(c, this));
- d_subtheoryMap[SUB_ALGEBRAIC] = d_subtheories.back().get();
- }
-
- BitblastSolver* bb_solver = new BitblastSolver(c, this);
- if (options().bv.bvAbstraction)
- {
- bb_solver->setAbstraction(d_abstractionModule.get());
- }
- d_subtheories.emplace_back(bb_solver);
- d_subtheoryMap[SUB_BITBLAST] = bb_solver;
-}
-
-BVSolverLayered::~BVSolverLayered() {}
-
-bool BVSolverLayered::needsEqualityEngine(EeSetupInfo& esi)
-{
- CoreSolver* core = (CoreSolver*)d_subtheoryMap[SUB_CORE];
- if (core)
- {
- return core->needsEqualityEngine(esi);
- }
- // otherwise we don't use an equality engine
- return false;
-}
-
-void BVSolverLayered::finishInit()
-{
- CoreSolver* core = (CoreSolver*)d_subtheoryMap[SUB_CORE];
- if (core)
- {
- // must finish initialization in the core solver
- core->finishInit();
- }
-}
-
-void BVSolverLayered::spendResource(Resource r) { d_im.spendResource(r); }
-
-BVSolverLayered::Statistics::Statistics()
- : d_avgConflictSize(smtStatisticsRegistry().registerAverage(
- "theory::bv::lazy::AvgBVConflictSize")),
- d_solveTimer(smtStatisticsRegistry().registerTimer(
- "theory::bv::lazy::solveTimer")),
- d_numCallsToCheckFullEffort(smtStatisticsRegistry().registerInt(
- "theory::bv::lazy::NumFullCheckCalls")),
- d_numCallsToCheckStandardEffort(smtStatisticsRegistry().registerInt(
- "theory::bv::lazy::NumStandardCheckCalls")),
- d_weightComputationTimer(smtStatisticsRegistry().registerTimer(
- "theory::bv::lazy::weightComputationTimer")),
- d_numMultSlice(smtStatisticsRegistry().registerInt(
- "theory::bv::lazy::NumMultSliceApplied"))
-{
-}
-
-void BVSolverLayered::preRegisterTerm(TNode node)
-{
- d_calledPreregister = true;
- Debug("bitvector-preregister")
- << "BVSolverLayered::preRegister(" << node << ")" << std::endl;
-
- if (options().bv.bitblastMode == options::BitblastMode::EAGER)
- {
- // the aig bit-blaster option is set heuristically
- // if bv abstraction is used
- if (!d_eagerSolver->isInitialized())
- {
- d_eagerSolver->initialize();
- }
-
- if (node.getKind() == kind::BITVECTOR_EAGER_ATOM)
- {
- Node formula = node[0];
- d_eagerSolver->assertFormula(formula);
- }
- return;
- }
-
- for (unsigned i = 0; i < d_subtheories.size(); ++i)
- {
- d_subtheories[i]->preRegister(node);
- }
-
- // AJR : equality solver currently registers all terms to ExtTheory, if we
- // want a lazy reduction without the bv equality solver, need to call this
- // d_bv.d_extTheory->registerTermRec( node );
-}
-
-void BVSolverLayered::sendConflict()
-{
- Assert(d_conflict);
- if (d_conflictNode.isNull())
- {
- return;
- }
- else
- {
- Debug("bitvector") << indent() << "BVSolverLayered::check(): conflict "
- << d_conflictNode << std::endl;
- d_im.conflict(d_conflictNode, InferenceId::BV_LAYERED_CONFLICT);
- d_statistics.d_avgConflictSize << d_conflictNode.getNumChildren();
- d_conflictNode = Node::null();
- }
-}
-
-void BVSolverLayered::checkForLemma(TNode fact)
-{
- if (fact.getKind() == kind::EQUAL)
- {
- NodeManager* nm = NodeManager::currentNM();
- if (fact[0].getKind() == kind::BITVECTOR_UREM)
- {
- TNode urem = fact[0];
- TNode result = fact[1];
- TNode divisor = urem[1];
- Node result_ult_div = nm->mkNode(kind::BITVECTOR_ULT, result, divisor);
- Node divisor_eq_0 =
- nm->mkNode(kind::EQUAL, divisor, mkZero(getSize(divisor)));
- Node split = nm->mkNode(
- kind::OR, divisor_eq_0, nm->mkNode(kind::NOT, fact), result_ult_div);
- lemma(split);
- }
- if (fact[1].getKind() == kind::BITVECTOR_UREM)
- {
- TNode urem = fact[1];
- TNode result = fact[0];
- TNode divisor = urem[1];
- Node result_ult_div = nm->mkNode(kind::BITVECTOR_ULT, result, divisor);
- Node divisor_eq_0 =
- nm->mkNode(kind::EQUAL, divisor, mkZero(getSize(divisor)));
- Node split = nm->mkNode(
- kind::OR, divisor_eq_0, nm->mkNode(kind::NOT, fact), result_ult_div);
- lemma(split);
- }
- }
-}
-
-bool BVSolverLayered::preCheck(Theory::Effort e)
-{
- check(e);
- return true;
-}
-
-void BVSolverLayered::check(Theory::Effort e)
-{
- if (done() && e < Theory::EFFORT_FULL)
- {
- return;
- }
-
- Debug("bitvector") << "BVSolverLayered::check(" << e << ")" << std::endl;
- TimerStat::CodeTimer codeTimer(d_statistics.d_solveTimer);
- // we may be getting new assertions so the model cache may not be sound
- d_invalidateModelCache.set(true);
- // if we are using the eager solver
- if (options().bv.bitblastMode == options::BitblastMode::EAGER)
- {
- // this can only happen on an empty benchmark
- if (!d_eagerSolver->isInitialized())
- {
- d_eagerSolver->initialize();
- }
- if (!Theory::fullEffort(e)) return;
-
- std::vector<TNode> assertions;
- while (!done())
- {
- TNode fact = get().d_assertion;
- Assert(fact.getKind() == kind::BITVECTOR_EAGER_ATOM);
- assertions.push_back(fact);
- d_eagerSolver->assertFormula(fact[0]);
- }
-
- bool ok = d_eagerSolver->checkSat();
- if (!ok)
- {
- if (assertions.size() == 1)
- {
- d_im.conflict(assertions[0], InferenceId::BV_LAYERED_CONFLICT);
- return;
- }
- Node conflict = utils::mkAnd(assertions);
- d_im.conflict(conflict, InferenceId::BV_LAYERED_CONFLICT);
- return;
- }
- return;
- }
-
- if (Theory::fullEffort(e))
- {
- ++(d_statistics.d_numCallsToCheckFullEffort);
- }
- else
- {
- ++(d_statistics.d_numCallsToCheckStandardEffort);
- }
- // if we are already in conflict just return the conflict
- if (inConflict())
- {
- sendConflict();
- return;
- }
-
- while (!done())
- {
- TNode fact = get().d_assertion;
-
- checkForLemma(fact);
-
- for (unsigned i = 0; i < d_subtheories.size(); ++i)
- {
- d_subtheories[i]->assertFact(fact);
- }
- }
-
- bool ok = true;
- bool complete = false;
- for (unsigned i = 0; i < d_subtheories.size(); ++i)
- {
- Assert(!inConflict());
- ok = d_subtheories[i]->check(e);
- complete = d_subtheories[i]->isComplete();
-
- if (!ok)
- {
- // if we are in a conflict no need to check with other theories
- Assert(inConflict());
- sendConflict();
- return;
- }
- if (complete)
- {
- // if the last subtheory was complete we stop
- break;
- }
- }
-}
-
-bool BVSolverLayered::collectModelValues(TheoryModel* m,
- const std::set<Node>& termSet)
-{
- Assert(!inConflict());
- if (options().bv.bitblastMode == options::BitblastMode::EAGER)
- {
- if (!d_eagerSolver->collectModelInfo(m, true))
- {
- return false;
- }
- }
- for (unsigned i = 0; i < d_subtheories.size(); ++i)
- {
- if (d_subtheories[i]->isComplete())
- {
- return d_subtheories[i]->collectModelValues(m, termSet);
- }
- }
- return true;
-}
-
-Node BVSolverLayered::getModelValue(TNode var)
-{
- Assert(!inConflict());
- for (unsigned i = 0; i < d_subtheories.size(); ++i)
- {
- if (d_subtheories[i]->isComplete())
- {
- return d_subtheories[i]->getModelValue(var);
- }
- }
- Unreachable();
-}
-
-void BVSolverLayered::propagate(Theory::Effort e)
-{
- Debug("bitvector") << indent() << "BVSolverLayered::propagate()" << std::endl;
- if (options().bv.bitblastMode == options::BitblastMode::EAGER)
- {
- return;
- }
-
- if (inConflict())
- {
- return;
- }
-
- // go through stored propagations
- bool ok = true;
- for (; d_literalsToPropagateIndex < d_literalsToPropagate.size() && ok;
- d_literalsToPropagateIndex = d_literalsToPropagateIndex + 1)
- {
- TNode literal = d_literalsToPropagate[d_literalsToPropagateIndex];
- // temporary fix for incremental bit-blasting
- if (d_state.isSatLiteral(literal))
- {
- Debug("bitvector::propagate")
- << "BVSolverLayered:: propagating " << literal << "\n";
- ok = d_im.propagateLit(literal);
- }
- }
-
- if (!ok)
- {
- Debug("bitvector::propagate")
- << indent()
- << "BVSolverLayered::propagate(): conflict from theory engine"
- << std::endl;
- setConflict();
- }
-}
-
-void BVSolverLayered::presolve()
-{
- Debug("bitvector") << "BVSolverLayered::presolve" << std::endl;
-}
-
-static int prop_count = 0;
-
-bool BVSolverLayered::storePropagation(TNode literal, SubTheory subtheory)
-{
- Debug("bitvector::propagate")
- << indent() << d_context->getLevel() << " "
- << "BVSolverLayered::storePropagation(" << literal << ", " << subtheory
- << ")" << std::endl;
- prop_count++;
-
- // If already in conflict, no more propagation
- if (d_conflict)
- {
- Debug("bitvector::propagate")
- << indent() << "BVSolverLayered::storePropagation(" << literal << ", "
- << subtheory << "): already in conflict" << std::endl;
- return false;
- }
-
- // If propagated already, just skip
- PropagatedMap::const_iterator find = d_propagatedBy.find(literal);
- if (find != d_propagatedBy.end())
- {
- return true;
- }
- else
- {
- bool polarity = literal.getKind() != kind::NOT;
- Node negatedLiteral = polarity ? literal.notNode() : (Node)literal[0];
- find = d_propagatedBy.find(negatedLiteral);
- if (find != d_propagatedBy.end() && (*find).second != subtheory)
- {
- // Safe to ignore this one, subtheory should produce a conflict
- return true;
- }
-
- d_propagatedBy[literal] = subtheory;
- }
-
- // Propagate differs depending on the subtheory
- // * bitblaster needs to be left alone until it's done, otherwise it doesn't
- // know how to explain
- // * equality engine can propagate eagerly
- // TODO(2348): Determine if ok should be set by propagate. If not, remove ok.
- constexpr bool ok = true;
- if (subtheory == SUB_CORE)
- {
- d_im.propagateLit(literal);
- if (!ok)
- {
- setConflict();
- }
- }
- else
- {
- d_literalsToPropagate.push_back(literal);
- }
- return ok;
-
-} /* BVSolverLayered::propagate(TNode) */
-
-void BVSolverLayered::explain(TNode literal, std::vector<TNode>& assumptions)
-{
- Assert(wasPropagatedBySubtheory(literal));
- SubTheory sub = getPropagatingSubtheory(literal);
- d_subtheoryMap[sub]->explain(literal, assumptions);
-}
-
-TrustNode BVSolverLayered::explain(TNode node)
-{
- Debug("bitvector::explain")
- << "BVSolverLayered::explain(" << node << ")" << std::endl;
- std::vector<TNode> assumptions;
-
- // Ask for the explanation
- explain(node, assumptions);
- // this means that it is something true at level 0
- Node explanation;
- if (assumptions.size() == 0)
- {
- explanation = utils::mkTrue();
- }
- else
- {
- // return the explanation
- explanation = utils::mkAnd(assumptions);
- }
- Debug("bitvector::explain") << "BVSolverLayered::explain(" << node << ") => "
- << explanation << std::endl;
- Debug("bitvector::explain") << "BVSolverLayered::explain done. \n";
- return TrustNode::mkTrustPropExp(node, explanation, nullptr);
-}
-
-void BVSolverLayered::notifySharedTerm(TNode t)
-{
- Debug("bitvector::sharing")
- << indent() << "BVSolverLayered::notifySharedTerm(" << t << ")"
- << std::endl;
- d_sharedTermsSet.insert(t);
-}
-
-EqualityStatus BVSolverLayered::getEqualityStatus(TNode a, TNode b)
-{
- if (options().bv.bitblastMode == options::BitblastMode::EAGER)
- return EQUALITY_UNKNOWN;
- Assert(options().bv.bitblastMode == options::BitblastMode::LAZY);
- for (unsigned i = 0; i < d_subtheories.size(); ++i)
- {
- EqualityStatus status = d_subtheories[i]->getEqualityStatus(a, b);
- if (status != EQUALITY_UNKNOWN)
- {
- return status;
- }
- }
- return EQUALITY_UNKNOWN;
- ;
-}
-
-bool BVSolverLayered::applyAbstraction(const std::vector<Node>& assertions,
- std::vector<Node>& new_assertions)
-{
- bool changed =
- d_abstractionModule->applyAbstraction(assertions, new_assertions);
- if (changed && options().bv.bitblastMode == options::BitblastMode::EAGER
- && options().bv.bitvectorAig)
- {
- // disable AIG mode
- AlwaysAssert(!d_eagerSolver->isInitialized());
- d_eagerSolver->turnOffAig();
- d_eagerSolver->initialize();
- }
- return changed;
-}
-
-void BVSolverLayered::setConflict(Node conflict)
-{
- if (options().bv.bvAbstraction)
- {
- NodeManager* const nm = NodeManager::currentNM();
- Node new_conflict = d_abstractionModule->simplifyConflict(conflict);
-
- std::vector<Node> lemmas;
- lemmas.push_back(new_conflict);
- d_abstractionModule->generalizeConflict(new_conflict, lemmas);
- for (unsigned i = 0; i < lemmas.size(); ++i)
- {
- lemma(nm->mkNode(kind::NOT, lemmas[i]));
- }
- }
- d_conflict = true;
- d_conflictNode = conflict;
-}
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Mathias Preiner, Liana Hadarean, Andrew Reynolds
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Layered bit-vector solver.
- */
-
-#include "cvc5_private.h"
-
-#ifndef CVC5__THEORY__BV__BV_SOLVER_LAYERED_H
-#define CVC5__THEORY__BV__BV_SOLVER_LAYERED_H
-
-#include <unordered_map>
-#include <unordered_set>
-
-#include "context/cdhashset.h"
-#include "context/cdlist.h"
-#include "context/context.h"
-#include "smt/env_obj.h"
-#include "theory/bv/bv_solver.h"
-#include "theory/bv/bv_subtheory.h"
-#include "theory/bv/theory_bv.h"
-#include "util/hash.h"
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-class CoreSolver;
-class InequalitySolver;
-class AlgebraicSolver;
-class BitblastSolver;
-class EagerBitblastSolver;
-class AbstractionModule;
-
-class BVSolverLayered : public BVSolver
-{
- /** Back reference to TheoryBV */
- TheoryBV& d_bv;
-
- /** The context we are using */
- context::Context* d_context;
-
- /** Context dependent set of atoms we already propagated */
- context::CDHashSet<Node> d_alreadyPropagatedSet;
- context::CDHashSet<Node> d_sharedTermsSet;
-
- std::vector<std::unique_ptr<SubtheorySolver>> d_subtheories;
- std::unordered_map<SubTheory, SubtheorySolver*, std::hash<int>>
- d_subtheoryMap;
-
- public:
- BVSolverLayered(Env& env,
- TheoryBV& bv,
- context::Context* c,
- context::UserContext* u,
- ProofNodeManager* pnm = nullptr,
- std::string name = "");
-
- ~BVSolverLayered();
-
- //--------------------------------- initialization
-
- /**
- * Returns true if we need an equality engine. If so, we initialize the
- * information regarding how it should be setup. For details, see the
- * documentation in Theory::needsEqualityEngine.
- */
- bool needsEqualityEngine(EeSetupInfo& esi) override;
-
- /** finish initialization */
- void finishInit() override;
- //--------------------------------- end initialization
-
- void preRegisterTerm(TNode n) override;
-
- bool preCheck(Theory::Effort e) override;
-
- void propagate(Theory::Effort e) override;
-
- TrustNode explain(TNode n) override;
-
- bool collectModelValues(TheoryModel* m,
- const std::set<Node>& termSet) override;
-
- std::string identify() const override
- {
- return std::string("BVSolverLayered");
- }
-
- void presolve() override;
-
- bool applyAbstraction(const std::vector<Node>& assertions,
- std::vector<Node>& new_assertions) override;
-
- bool isLeaf(TNode node) { return d_bv.isLeaf(node); }
-
- private:
- class Statistics
- {
- public:
- AverageStat d_avgConflictSize;
- TimerStat d_solveTimer;
- IntStat d_numCallsToCheckFullEffort;
- IntStat d_numCallsToCheckStandardEffort;
- TimerStat d_weightComputationTimer;
- IntStat d_numMultSlice;
- Statistics();
- };
-
- Statistics d_statistics;
-
- void check(Theory::Effort e);
- void spendResource(Resource r);
-
- typedef std::unordered_set<TNode> TNodeSet;
- typedef std::unordered_set<Node> NodeSet;
-
- typedef std::unordered_map<Node, Node> NodeToNode;
-
- context::CDO<bool> d_lemmasAdded;
-
- // Are we in conflict?
- context::CDO<bool> d_conflict;
-
- // Invalidate the model cache if check was called
- context::CDO<bool> d_invalidateModelCache;
-
- /** The conflict node */
- Node d_conflictNode;
-
- /** Literals to propagate */
- context::CDList<Node> d_literalsToPropagate;
-
- /** Index of the next literal to propagate */
- context::CDO<unsigned> d_literalsToPropagateIndex;
-
- /**
- * Keeps a map from nodes to the subtheory that propagated it so that we can
- * explain it properly.
- */
- typedef context::CDHashMap<Node, SubTheory> PropagatedMap;
- PropagatedMap d_propagatedBy;
-
- std::unique_ptr<EagerBitblastSolver> d_eagerSolver;
- std::unique_ptr<AbstractionModule> d_abstractionModule;
- bool d_calledPreregister;
-
- bool wasPropagatedBySubtheory(TNode literal) const
- {
- return d_propagatedBy.find(literal) != d_propagatedBy.end();
- }
-
- SubTheory getPropagatingSubtheory(TNode literal) const
- {
- Assert(wasPropagatedBySubtheory(literal));
- PropagatedMap::const_iterator find = d_propagatedBy.find(literal);
- return (*find).second;
- }
-
- /** Should be called to propagate the literal. */
- bool storePropagation(TNode literal, SubTheory subtheory);
-
- /**
- * Explains why this literal (propagated by subtheory) is true by adding
- * assumptions.
- */
- void explain(TNode literal, std::vector<TNode>& assumptions);
-
- void notifySharedTerm(TNode t) override;
-
- bool isSharedTerm(TNode t) { return d_sharedTermsSet.contains(t); }
-
- EqualityStatus getEqualityStatus(TNode a, TNode b) override;
-
- Node getModelValue(TNode var);
-
- inline std::string indent()
- {
- std::string indentStr(d_context->getLevel(), ' ');
- return indentStr;
- }
-
- void setConflict(Node conflict = Node::null());
-
- bool inConflict() { return d_conflict; }
-
- void sendConflict();
-
- void lemma(TNode node)
- {
- d_im.lemma(node, InferenceId::BV_LAYERED_LEMMA);
- d_lemmasAdded = true;
- }
-
- void checkForLemma(TNode node);
-
- size_t numAssertions() { return d_bv.numAssertions(); }
-
- theory::Assertion get() { return d_bv.get(); }
-
- bool done() { return d_bv.done(); }
-
- friend class LazyBitblaster;
- friend class TLazyBitblaster;
- friend class EagerBitblaster;
- friend class BitblastSolver;
- friend class EqualitySolver;
- friend class CoreSolver;
- friend class InequalitySolver;
- friend class AlgebraicSolver;
- friend class EagerBitblastSolver;
-}; /* class BVSolverLayered */
-
-} // namespace bv
-} // namespace theory
-
-} // namespace cvc5
-
-#endif /* CVC5__THEORY__BV__BV_SOLVER_LAZY_H */
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Tim King, Dejan Jovanovic
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Interface for bit-vectors sub-solvers.
- */
-
-#ifndef CVC5__THEORY__BV__BV_SUBTHEORY_H
-#define CVC5__THEORY__BV__BV_SUBTHEORY_H
-
-#include "context/cdqueue.h"
-#include "context/context.h"
-#include "cvc5_private.h"
-#include "theory/theory.h"
-#include "theory/uf/equality_engine.h"
-
-namespace cvc5 {
-
-namespace theory {
-
-class TheoryModel;
-
-namespace bv {
-
-enum SubTheory {
- SUB_CORE = 1,
- SUB_BITBLAST = 2,
- SUB_INEQUALITY = 3,
- SUB_ALGEBRAIC = 4
-};
-
-inline std::ostream& operator<<(std::ostream& out, SubTheory subtheory) {
- switch (subtheory) {
- case SUB_BITBLAST:
- return out << "BITBLASTER";
- case SUB_CORE:
- return out << "BV_CORE_SUBTHEORY";
- case SUB_INEQUALITY:
- return out << "BV_INEQUALITY_SUBTHEORY";
- case SUB_ALGEBRAIC:
- return out << "BV_ALGEBRAIC_SUBTHEORY";
- default:
- break;
- }
- Unreachable();
-}
-
-// forward declaration
-class BVSolverLayered;
-
-using AssertionQueue = context::CDQueue<Node>;
-
-/**
- * Abstract base class for bit-vector subtheory solvers
- *
- */
-class SubtheorySolver {
- public:
- SubtheorySolver(context::Context* c, BVSolverLayered* bv)
- : d_context(c), d_bv(bv), d_assertionQueue(c), d_assertionIndex(c, 0)
- {
- }
- virtual ~SubtheorySolver() {}
- virtual bool check(Theory::Effort e) = 0;
- virtual void explain(TNode literal, std::vector<TNode>& assumptions) = 0;
- virtual void preRegister(TNode node) {}
- virtual void propagate(Theory::Effort e) {}
- virtual bool collectModelValues(TheoryModel* m,
- const std::set<Node>& termSet) = 0;
- virtual Node getModelValue(TNode var) = 0;
- virtual bool isComplete() = 0;
- virtual EqualityStatus getEqualityStatus(TNode a, TNode b) = 0;
- bool done() { return d_assertionQueue.size() == d_assertionIndex; }
- TNode get() {
- Assert(!done());
- TNode res = d_assertionQueue[d_assertionIndex];
- d_assertionIndex = d_assertionIndex + 1;
- return res;
- }
- virtual void assertFact(TNode fact) { d_assertionQueue.push_back(fact); }
-
- AssertionQueue::const_iterator assertionsBegin() {
- return d_assertionQueue.begin();
- }
- AssertionQueue::const_iterator assertionsEnd() {
- return d_assertionQueue.end();
- }
-
- protected:
- /** The context we are using */
- context::Context* d_context;
-
- /** The bit-vector theory */
- BVSolverLayered* d_bv;
- AssertionQueue d_assertionQueue;
- context::CDO<uint32_t> d_assertionIndex;
-}; /* class SubtheorySolver */
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
-
-#endif /* CVC5__THEORY__BV__BV_SUBTHEORY_H */
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Aina Niemetz, Mathias Preiner
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Algebraic solver.
- */
-#include "theory/bv/bv_subtheory_algebraic.h"
-
-#include <unordered_set>
-
-#include "expr/node_algorithm.h"
-#include "options/bv_options.h"
-#include "printer/printer.h"
-#include "smt/dump.h"
-#include "smt/smt_statistics_registry.h"
-#include "smt/solver_engine.h"
-#include "smt/solver_engine_scope.h"
-#include "smt_util/boolean_simplification.h"
-#include "theory/bv/bv_quick_check.h"
-#include "theory/bv/bv_solver_layered.h"
-#include "theory/bv/theory_bv_utils.h"
-#include "theory/rewriter.h"
-#include "theory/theory_model.h"
-#include "util/bitvector.h"
-
-using namespace cvc5::context;
-using namespace cvc5::prop;
-using namespace cvc5::theory::bv::utils;
-using namespace std;
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-/* ------------------------------------------------------------------------- */
-
-namespace {
-
-/* Collect all variables under a given a node. */
-void collectVariables(TNode node, utils::NodeSet& vars)
-{
- std::vector<TNode> stack;
- std::unordered_set<TNode> visited;
-
- stack.push_back(node);
- while (!stack.empty())
- {
- Node n = stack.back();
- stack.pop_back();
-
- if (vars.find(n) != vars.end()) continue;
- if (visited.find(n) != visited.end()) continue;
- visited.insert(n);
-
- if (Theory::isLeafOf(n, THEORY_BV) && n.getKind() != kind::CONST_BITVECTOR)
- {
- vars.insert(n);
- continue;
- }
- stack.insert(stack.end(), n.begin(), n.end());
- }
-}
-
-};
-
-/* ------------------------------------------------------------------------- */
-
-bool hasExpensiveBVOperators(TNode fact);
-Node mergeExplanations(const std::vector<Node>& expls);
-Node mergeExplanations(TNode expl1, TNode expl2);
-
-
-SubstitutionEx::SubstitutionEx(theory::SubstitutionMap* modelMap)
- : d_substitutions()
- , d_cache()
- , d_cacheInvalid(true)
- , d_modelMap(modelMap)
-{}
-
-bool SubstitutionEx::addSubstitution(TNode from, TNode to, TNode reason) {
- Debug("bv-substitution") << "SubstitutionEx::addSubstitution: "<< from
- <<" => "<< to << "\n" << " reason "<<reason << "\n";
- Assert(from != to);
- if (d_substitutions.find(from) != d_substitutions.end()) {
- return false;
- }
-
- d_modelMap->addSubstitution(from, to);
-
- d_cacheInvalid = true;
- d_substitutions[from] = SubstitutionElement(to, reason);
- return true;
-}
-
-Node SubstitutionEx::apply(TNode node) {
- Debug("bv-substitution") << "SubstitutionEx::apply("<< node <<")\n";
- if (d_cacheInvalid) {
- d_cache.clear();
- d_cacheInvalid = false;
- }
-
- SubstitutionsCache::iterator it = d_cache.find(node);
-
- if (it != d_cache.end()) {
- Node res = it->second.to;
- Debug("bv-substitution") << " =>"<< res <<"\n";
- return res;
- }
-
- Node result = internalApply(node);
- Debug("bv-substitution") << " =>"<< result <<"\n";
- return result;
-}
-
-Node SubstitutionEx::internalApply(TNode node) {
- if (d_substitutions.empty())
- return node;
-
- vector<SubstitutionStackElement> stack;
- stack.push_back(SubstitutionStackElement(node));
-
- while (!stack.empty()) {
- SubstitutionStackElement head = stack.back();
- stack.pop_back();
-
- TNode current = head.node;
-
- if (hasCache(current)) {
- continue;
- }
-
- // check if it has substitution
- Substitutions::const_iterator it = d_substitutions.find(current);
- if (it != d_substitutions.end()) {
- vector<Node> reasons;
- TNode to = it->second.to;
- reasons.push_back(it->second.reason);
- // check if the thing we subsituted to has substitutions
- TNode res = internalApply(to);
- // update reasons
- reasons.push_back(getReason(to));
- Node reason = mergeExplanations(reasons);
- storeCache(current, res, reason);
- continue;
- }
-
- // if no children then just continue
- if(current.getNumChildren() == 0) {
- storeCache(current, current, utils::mkTrue());
- continue;
- }
-
- // children already processed
- if (head.childrenAdded) {
- NodeBuilder nb(current.getKind());
- std::vector<Node> reasons;
-
- if (current.getMetaKind() == kind::metakind::PARAMETERIZED) {
- TNode op = current.getOperator();
- Assert(hasCache(op));
- nb << getCache(op);
- reasons.push_back(getReason(op));
- }
- for (unsigned i = 0; i < current.getNumChildren(); ++i) {
- Assert(hasCache(current[i]));
- nb << getCache(current[i]);
- reasons.push_back(getReason(current[i]));
- }
- Node result = nb;
- // if the node is new apply substitutions to it
- Node subst_result = result;
- if (result != current) {
- subst_result = result!= current? internalApply(result) : result;
- reasons.push_back(getReason(result));
- }
- Node reason = mergeExplanations(reasons);
- storeCache(current, subst_result, reason);
- continue;
- } else {
- // add children to stack
- stack.push_back(SubstitutionStackElement(current, true));
- if (current.getMetaKind() == kind::metakind::PARAMETERIZED) {
- stack.push_back(SubstitutionStackElement(current.getOperator()));
- }
- for (unsigned i = 0; i < current.getNumChildren(); ++i) {
- stack.push_back(SubstitutionStackElement(current[i]));
- }
- }
- }
-
- Assert(hasCache(node));
- return getCache(node);
-}
-
-Node SubstitutionEx::explain(TNode node) const {
- if(!hasCache(node)) {
- return utils::mkTrue();
- }
-
- Debug("bv-substitution") << "SubstitutionEx::explain("<< node <<")\n";
- Node res = getReason(node);
- Debug("bv-substitution") << " with "<< res <<"\n";
- return res;
-}
-
-Node SubstitutionEx::getReason(TNode node) const {
- Assert(hasCache(node));
- SubstitutionsCache::const_iterator it = d_cache.find(node);
- return it->second.reason;
-}
-
-bool SubstitutionEx::hasCache(TNode node) const {
- return d_cache.find(node) != d_cache.end();
-}
-
-Node SubstitutionEx::getCache(TNode node) const {
- Assert(hasCache(node));
- return d_cache.find(node)->second.to;
-}
-
-void SubstitutionEx::storeCache(TNode from, TNode to, Node reason) {
- // Debug("bv-substitution") << "SubstitutionEx::storeCache(" << from <<", " << to <<", "<< reason<<")\n";
- Assert(!hasCache(from));
- d_cache[from] = SubstitutionElement(to, reason);
-}
-
-AlgebraicSolver::AlgebraicSolver(context::Context* c, BVSolverLayered* bv)
- : SubtheorySolver(c, bv),
- d_modelMap(),
- d_quickSolver(new BVQuickCheck("theory::bv::algebraic", bv)),
- d_isComplete(c, false),
- d_isDifficult(c, false),
- d_budget(options::bitvectorAlgebraicBudget()),
- d_explanations(),
- d_inputAssertions(),
- d_ids(),
- d_numSolved(0),
- d_numCalls(0),
- d_quickXplain(),
- d_statistics()
-{
- if (options::bitvectorQuickXplain())
- {
- d_quickXplain.reset(
- new QuickXPlain("theory::bv::algebraic", d_quickSolver.get()));
- }
-}
-
-AlgebraicSolver::~AlgebraicSolver() {}
-
-bool AlgebraicSolver::check(Theory::Effort e)
-{
- Assert(options::bitblastMode() == options::BitblastMode::LAZY);
-
- if (!Theory::fullEffort(e)) { return true; }
- if (!useHeuristic()) { return true; }
-
- TimerStat::CodeTimer algebraicTimer(d_statistics.d_solveTime);
- Debug("bv-subtheory-algebraic") << "AlgebraicSolver::check (" << e << ")\n";
- ++(d_numCalls);
- ++(d_statistics.d_numCallstoCheck);
-
- d_explanations.clear();
- d_ids.clear();
- d_inputAssertions.clear();
-
- std::vector<WorklistElement> worklist;
-
- uint64_t original_bb_cost = 0;
-
- NodeSet seen_assertions;
- // Processing assertions from scratch
- for (AssertionQueue::const_iterator it = assertionsBegin(); it != assertionsEnd(); ++it) {
- Debug("bv-subtheory-algebraic") << " " << *it << "\n";
- TNode assertion = *it;
- unsigned id = worklist.size();
- d_ids[assertion] = id;
- worklist.push_back(WorklistElement(assertion, id));
- d_inputAssertions.insert(assertion);
- storeExplanation(assertion);
-
- uint64_t assertion_size = d_quickSolver->computeAtomWeight(assertion, seen_assertions);
- Assert(original_bb_cost <= original_bb_cost + assertion_size);
- original_bb_cost+= assertion_size;
- }
-
- for (unsigned i = 0; i < worklist.size(); ++i) {
- d_ids[worklist[i].node] = worklist[i].id;
- }
-
- Debug("bv-subtheory-algebraic") << "Assertions " << worklist.size() <<" : \n";
-
- Assert(d_explanations.size() == worklist.size());
-
- d_modelMap.reset(new SubstitutionMap(d_context));
- SubstitutionEx subst(d_modelMap.get());
-
- // first round of substitutions
- processAssertions(worklist, subst);
-
- if (!d_isDifficult.get()) {
- // skolemize all possible extracts
- ExtractSkolemizer skolemizer(d_modelMap.get());
- skolemizer.skolemize(worklist);
- // second round of substitutions
- processAssertions(worklist, subst);
- }
-
- NodeSet subst_seen;
- uint64_t subst_bb_cost = 0;
-
- unsigned r = 0;
- unsigned w = 0;
-
- for (; r < worklist.size(); ++r) {
-
- TNode fact = worklist[r].node;
- unsigned id = worklist[r].id;
-
- if (fact.isConst() &&
- fact.getConst<bool>() == true) {
- continue;
- }
-
- if (fact.isConst() &&
- fact.getConst<bool>() == false) {
- // we have a conflict
- Node conflict = BooleanSimplification::simplify(d_explanations[id]);
- d_bv->setConflict(conflict);
- d_isComplete.set(true);
- Debug("bv-subtheory-algebraic") << " UNSAT: assertion simplfies to false with conflict: "<< conflict << "\n";
-
- ++(d_statistics.d_numSimplifiesToFalse);
- ++(d_numSolved);
- return false;
- }
-
- subst_bb_cost+= d_quickSolver->computeAtomWeight(fact, subst_seen);
- worklist[w] = WorklistElement(fact, id);
- Node expl = BooleanSimplification::simplify(d_explanations[id]);
- storeExplanation(id, expl);
- d_ids[fact] = id;
- ++w;
- }
-
- worklist.resize(w);
-
-
- if(Debug.isOn("bv-subtheory-algebraic")) {
- Debug("bv-subtheory-algebraic") << "Assertions post-substitutions " << worklist.size() << ":\n";
- for (unsigned i = 0; i < worklist.size(); ++i) {
- Debug("bv-subtheory-algebraic") << " " << worklist[i].node << "\n";
- }
- }
-
-
- // all facts solved to true
- if (worklist.empty()) {
- Debug("bv-subtheory-algebraic") << " SAT: everything simplifies to true.\n";
- ++(d_statistics.d_numSimplifiesToTrue);
- ++(d_numSolved);
- return true;
- }
-
- double ratio = ((double)subst_bb_cost)/original_bb_cost;
- if (ratio > 0.5 ||
- !d_isDifficult.get()) {
- // give up if problem not reduced enough
- d_isComplete.set(false);
- return true;
- }
-
- d_quickSolver->clearSolver();
-
- d_quickSolver->push();
- std::vector<Node> facts;
- for (unsigned i = 0; i < worklist.size(); ++i) {
- facts.push_back(worklist[i].node);
- }
- bool ok = quickCheck(facts);
-
- Debug("bv-subtheory-algebraic") << "AlgebraicSolver::check done " << ok << ".\n";
- return ok;
-}
-
-bool AlgebraicSolver::quickCheck(std::vector<Node>& facts) {
- SatValue res = d_quickSolver->checkSat(facts, d_budget);
-
- if (res == SAT_VALUE_UNKNOWN) {
- d_isComplete.set(false);
- Debug("bv-subtheory-algebraic") << " Unknown.\n";
- ++(d_statistics.d_numUnknown);
- return true;
- }
-
- if (res == SAT_VALUE_TRUE) {
- Debug("bv-subtheory-algebraic") << " Sat.\n";
- ++(d_statistics.d_numSat);
- ++(d_numSolved);
- d_isComplete.set(true);
- return true;
- }
-
- Assert(res == SAT_VALUE_FALSE);
- Assert(d_quickSolver->inConflict());
- d_isComplete.set(true);
- Debug("bv-subtheory-algebraic") << " Unsat.\n";
- ++(d_numSolved);
- ++(d_statistics.d_numUnsat);
-
-
- Node conflict = d_quickSolver->getConflict();
- Debug("bv-subtheory-algebraic") << " Conflict: " << conflict << "\n";
-
- // singleton conflict
- if (conflict.getKind() != kind::AND) {
- Assert(d_ids.find(conflict) != d_ids.end());
- unsigned id = d_ids[conflict];
- Assert(id < d_explanations.size());
- Node theory_confl = d_explanations[id];
- d_bv->setConflict(theory_confl);
- return false;
- }
-
- Assert(conflict.getKind() == kind::AND);
- if (options::bitvectorQuickXplain()) {
- d_quickSolver->popToZero();
- Debug("bv-quick-xplain") << "AlgebraicSolver::quickCheck original conflict size " << conflict.getNumChildren() << "\n";
- conflict = d_quickXplain->minimizeConflict(conflict);
- Debug("bv-quick-xplain") << "AlgebraicSolver::quickCheck minimized conflict size " << conflict.getNumChildren() << "\n";
- }
-
- vector<TNode> theory_confl;
- for (unsigned i = 0; i < conflict.getNumChildren(); ++i) {
- TNode c = conflict[i];
-
- Assert(d_ids.find(c) != d_ids.end());
- unsigned c_id = d_ids[c];
- Assert(c_id < d_explanations.size());
- TNode c_expl = d_explanations[c_id];
- theory_confl.push_back(c_expl);
- }
-
- Node confl = BooleanSimplification::simplify(utils::mkAnd(theory_confl));
-
- Debug("bv-subtheory-algebraic") << " Out Conflict: " << confl << "\n";
- setConflict(confl);
- return false;
-}
-
-void AlgebraicSolver::setConflict(TNode conflict)
-{
- Node final_conflict = conflict;
- if (options::bitvectorQuickXplain() &&
- conflict.getKind() == kind::AND &&
- conflict.getNumChildren() > 4) {
- final_conflict = d_quickXplain->minimizeConflict(conflict);
- }
- d_bv->setConflict(final_conflict);
-}
-
-bool AlgebraicSolver::solve(TNode fact, TNode reason, SubstitutionEx& subst) {
- if (fact.getKind() != kind::EQUAL) return false;
-
- NodeManager* nm = NodeManager::currentNM();
- TNode left = fact[0];
- TNode right = fact[1];
-
- if (left.isVar() && !expr::hasSubterm(right, left))
- {
- bool changed = subst.addSubstitution(left, right, reason);
- return changed;
- }
- if (right.isVar() && !expr::hasSubterm(left, right))
- {
- bool changed = subst.addSubstitution(right, left, reason);
- return changed;
- }
-
- // xor simplification
- if (right.getKind() == kind::BITVECTOR_XOR &&
- left.getKind() == kind::BITVECTOR_XOR) {
- TNode var = left[0];
- if (var.getMetaKind() != kind::metakind::VARIABLE)
- return false;
-
- // simplify xor with same variable on both sides
- if (expr::hasSubterm(right, var))
- {
- std::vector<Node> right_children;
- for (unsigned i = 0; i < right.getNumChildren(); ++i) {
- if (right[i] != var)
- right_children.push_back(right[i]);
- }
- Assert(right_children.size());
- Node new_right = utils::mkNaryNode(kind::BITVECTOR_XOR, right_children);
- std::vector<Node> left_children;
- for (unsigned i = 1; i < left.getNumChildren(); ++i) {
- left_children.push_back(left[i]);
- }
- Node new_left = utils::mkNaryNode(kind::BITVECTOR_XOR, left_children);
- Node new_fact = nm->mkNode(kind::EQUAL, new_left, new_right);
- bool changed = subst.addSubstitution(fact, new_fact, reason);
- return changed;
- }
-
- NodeBuilder nb(kind::BITVECTOR_XOR);
- for (unsigned i = 1; i < left.getNumChildren(); ++i) {
- nb << left[i];
- }
- Node inverse = left.getNumChildren() == 2? (Node)left[1] : (Node)nb;
- Node new_right = nm->mkNode(kind::BITVECTOR_XOR, right, inverse);
- bool changed = subst.addSubstitution(var, new_right, reason);
-
- return changed;
- }
-
- // (a xor t = a) <=> (t = 0)
- if (left.getKind() == kind::BITVECTOR_XOR
- && right.getMetaKind() == kind::metakind::VARIABLE
- && expr::hasSubterm(left, right))
- {
- TNode var = right;
- Node new_left = nm->mkNode(kind::BITVECTOR_XOR, var, left);
- Node zero = utils::mkConst(utils::getSize(var), 0u);
- Node new_fact = nm->mkNode(kind::EQUAL, zero, new_left);
- bool changed = subst.addSubstitution(fact, new_fact, reason);
- return changed;
- }
-
- if (right.getKind() == kind::BITVECTOR_XOR
- && left.getMetaKind() == kind::metakind::VARIABLE
- && expr::hasSubterm(right, left))
- {
- TNode var = left;
- Node new_right = nm->mkNode(kind::BITVECTOR_XOR, var, right);
- Node zero = utils::mkConst(utils::getSize(var), 0u);
- Node new_fact = nm->mkNode(kind::EQUAL, zero, new_right);
- bool changed = subst.addSubstitution(fact, new_fact, reason);
- return changed;
- }
-
- // (a xor b = 0) <=> (a = b)
- if (left.getKind() == kind::BITVECTOR_XOR &&
- left.getNumChildren() == 2 &&
- right.getKind() == kind::CONST_BITVECTOR &&
- right.getConst<BitVector>() == BitVector(utils::getSize(left), 0u)) {
- Node new_fact = nm->mkNode(kind::EQUAL, left[0], left[1]);
- bool changed = subst.addSubstitution(fact, new_fact, reason);
- return changed;
- }
-
-
- return false;
-}
-
-bool AlgebraicSolver::isSubstitutableIn(TNode node, TNode in)
-{
- if (node.getMetaKind() == kind::metakind::VARIABLE
- && !expr::hasSubterm(in, node))
- return true;
- return false;
-}
-
-void AlgebraicSolver::processAssertions(std::vector<WorklistElement>& worklist, SubstitutionEx& subst) {
- NodeManager* nm = NodeManager::currentNM();
- bool changed = true;
- while(changed) {
- // d_bv->spendResource();
- changed = false;
- for (unsigned i = 0; i < worklist.size(); ++i) {
- // apply current substitutions
- Node current = subst.apply(worklist[i].node);
- unsigned current_id = worklist[i].id;
- Node subst_expl = subst.explain(worklist[i].node);
- worklist[i] = WorklistElement(Rewriter::rewrite(current), current_id);
- // explanation for this assertion
- Node old_expl = d_explanations[current_id];
- Node new_expl = mergeExplanations(subst_expl, old_expl);
- storeExplanation(current_id, new_expl);
-
- // use the new substitution to solve
- if(solve(worklist[i].node, new_expl, subst)) {
- changed = true;
- }
- }
-
- // check for concat slicings
- for (unsigned i = 0; i < worklist.size(); ++i) {
- TNode fact = worklist[i].node;
- unsigned current_id = worklist[i].id;
-
- if (fact.getKind() != kind::EQUAL) {
- continue;
- }
-
- TNode left = fact[0];
- TNode right = fact[1];
- if (left.getKind() != kind::BITVECTOR_CONCAT ||
- right.getKind() != kind::BITVECTOR_CONCAT ||
- left.getNumChildren() != right.getNumChildren()) {
- continue;
- }
-
- bool can_slice = true;
- for (unsigned j = 0; j < left.getNumChildren(); ++j) {
- if (utils::getSize(left[j]) != utils::getSize(right[j]))
- can_slice = false;
- }
-
- if (!can_slice) {
- continue;
- }
-
- for (unsigned j = 0; j < left.getNumChildren(); ++j) {
- Node eq_j = nm->mkNode(kind::EQUAL, left[j], right[j]);
- unsigned id = d_explanations.size();
- TNode expl = d_explanations[current_id];
- storeExplanation(expl);
- worklist.push_back(WorklistElement(eq_j, id));
- d_ids[eq_j] = id;
- }
- worklist[i] = WorklistElement(utils::mkTrue(), worklist[i].id);
- changed = true;
- }
- Assert(d_explanations.size() == worklist.size());
- }
-}
-
-void AlgebraicSolver::storeExplanation(unsigned id, TNode explanation) {
- Assert(checkExplanation(explanation));
- d_explanations[id] = explanation;
-}
-
-void AlgebraicSolver::storeExplanation(TNode explanation) {
- Assert(checkExplanation(explanation));
- d_explanations.push_back(explanation);
-}
-
-bool AlgebraicSolver::checkExplanation(TNode explanation) {
- Node simplified_explanation = explanation; //BooleanSimplification::simplify(explanation);
- if (simplified_explanation.getKind() != kind::AND) {
- return d_inputAssertions.find(simplified_explanation) != d_inputAssertions.end();
- }
- for (unsigned i = 0; i < simplified_explanation.getNumChildren(); ++i) {
- if (d_inputAssertions.find(simplified_explanation[i]) == d_inputAssertions.end()) {
- return false;
- }
- }
- return true;
-}
-
-
-bool AlgebraicSolver::isComplete() {
- return d_isComplete.get();
-}
-
-bool AlgebraicSolver::useHeuristic() {
- if (d_numCalls == 0)
- return true;
-
- double success_rate = double(d_numSolved)/double(d_numCalls);
- d_statistics.d_useHeuristic.set(success_rate);
- return success_rate > 0.8;
-}
-
-
-void AlgebraicSolver::assertFact(TNode fact) {
- d_assertionQueue.push_back(fact);
- d_isComplete.set(false);
- if (!d_isDifficult.get()) {
- d_isDifficult.set(hasExpensiveBVOperators(fact));
- }
-}
-
-EqualityStatus AlgebraicSolver::getEqualityStatus(TNode a, TNode b) {
- return EQUALITY_UNKNOWN;
-}
-
-bool AlgebraicSolver::collectModelValues(TheoryModel* model,
- const std::set<Node>& termSet)
-{
- Debug("bitvector-model") << "AlgebraicSolver::collectModelValues\n";
- AlwaysAssert(!d_quickSolver->inConflict());
-
- // collect relevant terms that the bv theory abstracts to variables
- // (variables and parametric terms such as select apply_uf)
- std::vector<TNode> variables;
- std::vector<Node> values;
- for (set<Node>::const_iterator it = termSet.begin(); it != termSet.end(); ++it) {
- TNode term = *it;
- if (term.getType().isBitVector() &&
- (term.getMetaKind() == kind::metakind::VARIABLE ||
- Theory::theoryOf(term) != THEORY_BV)) {
- variables.push_back(term);
- values.push_back(term);
- }
- }
-
- NodeSet leaf_vars;
- Debug("bitvector-model") << "Substitutions:\n";
- for (unsigned i = 0; i < variables.size(); ++i) {
- TNode current = variables[i];
- TNode subst = Rewriter::rewrite(d_modelMap->apply(current));
- Debug("bitvector-model") << " " << current << " => " << subst << "\n";
- values[i] = subst;
- collectVariables(subst, leaf_vars);
- }
-
- Debug("bitvector-model") << "Model:\n";
-
- for (NodeSet::const_iterator it = leaf_vars.begin(); it != leaf_vars.end(); ++it) {
- TNode var = *it;
- Node value = d_quickSolver->getVarValue(var, true);
- Assert(!value.isNull());
-
- // may be a shared term that did not appear in the current assertions
- // AJR: need to check whether already in map for cases where collectModelInfo is called multiple times in the same context
- if (!value.isNull() && !d_modelMap->hasSubstitution(var)) {
- Debug("bitvector-model") << " " << var << " => " << value << "\n";
- Assert(value.getKind() == kind::CONST_BITVECTOR);
- d_modelMap->addSubstitution(var, value);
- }
- }
-
- Debug("bitvector-model") << "Final Model:\n";
- for (unsigned i = 0; i < variables.size(); ++i) {
- TNode current = values[i];
- TNode subst = Rewriter::rewrite(d_modelMap->apply(current));
- Debug("bitvector-model") << "AlgebraicSolver: " << variables[i] << " => " << subst << "\n";
- // Doesn't have to be constant as it may be irrelevant
- Assert(subst.getKind() == kind::CONST_BITVECTOR);
- if (!model->assertEquality(variables[i], subst, true))
- {
- return false;
- }
- }
- return true;
- }
-
-Node AlgebraicSolver::getModelValue(TNode node) {
- return Node::null();
-}
-
-AlgebraicSolver::Statistics::Statistics()
- : d_numCallstoCheck(smtStatisticsRegistry().registerInt(
- "theory::bv::algebraic::NumCallsToCheck")),
- d_numSimplifiesToTrue(smtStatisticsRegistry().registerInt(
- "theory::bv::algebraic::NumSimplifiesToTrue")),
- d_numSimplifiesToFalse(smtStatisticsRegistry().registerInt(
- "theory::bv::algebraic::NumSimplifiesToFalse")),
- d_numUnsat(smtStatisticsRegistry().registerInt(
- "theory::bv::algebraic::NumUnsat")),
- d_numSat(
- smtStatisticsRegistry().registerInt("theory::bv::algebraic::NumSat")),
- d_numUnknown(smtStatisticsRegistry().registerInt(
- "theory::bv::algebraic::NumUnknown")),
- d_solveTime(smtStatisticsRegistry().registerTimer(
- "theory::bv::algebraic::SolveTime")),
- d_useHeuristic(smtStatisticsRegistry().registerValue<double>(
- "theory::bv::algebraic::UseHeuristic", 0.2))
-{
-}
-
-bool hasExpensiveBVOperatorsRec(TNode fact, TNodeSet& seen) {
- if (fact.getKind() == kind::BITVECTOR_MULT
- || fact.getKind() == kind::BITVECTOR_UDIV
- || fact.getKind() == kind::BITVECTOR_UREM)
- {
- return true;
- }
-
- if (seen.find(fact) != seen.end()) {
- return false;
- }
-
- if (fact.getNumChildren() == 0) {
- return false;
- }
- for (unsigned i = 0; i < fact.getNumChildren(); ++i) {
- bool difficult = hasExpensiveBVOperatorsRec(fact[i], seen);
- if (difficult)
- return true;
- }
- seen.insert(fact);
- return false;
-}
-
-bool hasExpensiveBVOperators(TNode fact) {
- TNodeSet seen;
- return hasExpensiveBVOperatorsRec(fact, seen);
-}
-
-void ExtractSkolemizer::skolemize(std::vector<WorklistElement>& facts) {
- TNodeSet seen;
- for (unsigned i = 0; i < facts.size(); ++i) {
- TNode current = facts[i].node;
- collectExtracts(current, seen);
- }
-
- for (VarExtractMap::iterator it = d_varToExtract.begin(); it != d_varToExtract.end(); ++it) {
- ExtractList& el = it->second;
- TNode var = it->first;
- Base& base = el.base;
-
- unsigned bw = utils::getSize(var);
- // compute decomposition
- std::vector<unsigned> cuts;
- for (unsigned i = 1; i <= bw; ++i) {
- if (base.isCutPoint(i)) {
- cuts.push_back(i);
- }
- }
- unsigned previous = 0;
- unsigned current = 0;
- std::vector<Node> skolems;
- for (unsigned i = 0; i < cuts.size(); ++i) {
- current = cuts[i];
- Assert(current > 0);
- int size = current - previous;
- Assert(size > 0);
- Node sk = utils::mkVar(size);
- skolems.push_back(sk);
- previous = current;
- }
- if (current < bw -1) {
- int size = bw - current;
- Assert(size > 0);
- Node sk = utils::mkVar(size);
- skolems.push_back(sk);
- }
- NodeBuilder skolem_nb(kind::BITVECTOR_CONCAT);
-
- for (int i = skolems.size() - 1; i >= 0; --i) {
- skolem_nb << skolems[i];
- }
-
- Node skolem_concat = skolems.size() == 1 ? (Node)skolems[0] : (Node) skolem_nb;
- Assert(utils::getSize(skolem_concat) == utils::getSize(var));
- storeSkolem(var, skolem_concat);
-
- for (unsigned i = 0; i < el.extracts.size(); ++i) {
- unsigned h = el.extracts[i].high;
- unsigned l = el.extracts[i].low;
- Node extract = utils::mkExtract(var, h, l);
- Node skolem_extract = Rewriter::rewrite(utils::mkExtract(skolem_concat, h, l));
- Assert(skolem_extract.getMetaKind() == kind::metakind::VARIABLE
- || skolem_extract.getKind() == kind::BITVECTOR_CONCAT);
- storeSkolem(extract, skolem_extract);
- }
- }
-
- for (unsigned i = 0; i < facts.size(); ++i) {
- facts[i] = WorklistElement(skolemize(facts[i].node), facts[i].id);
- }
-}
-
-Node ExtractSkolemizer::mkSkolem(Node node) {
- Assert(node.getKind() == kind::BITVECTOR_EXTRACT
- && node[0].getMetaKind() == kind::metakind::VARIABLE);
- Assert(!d_skolemSubst.hasSubstitution(node));
- return utils::mkVar(utils::getSize(node));
-}
-
-void ExtractSkolemizer::unSkolemize(std::vector<WorklistElement>& facts) {
- for (unsigned i = 0; i < facts.size(); ++i) {
- facts[i] = WorklistElement(unSkolemize(facts[i].node), facts[i].id);
- }
-}
-
-void ExtractSkolemizer::storeSkolem(TNode node, TNode skolem) {
- d_skolemSubst.addSubstitution(node, skolem);
- d_modelMap->addSubstitution(node, skolem);
- d_skolemSubstRev.addSubstitution(skolem, node);
-}
-
-Node ExtractSkolemizer::unSkolemize(TNode node) {
- return d_skolemSubstRev.apply(node);
-}
-
-Node ExtractSkolemizer::skolemize(TNode node) {
- return d_skolemSubst.apply(node);
-}
-
-void ExtractSkolemizer::ExtractList::addExtract(Extract& e) {
- extracts.push_back(e);
- base.sliceAt(e.low);
- base.sliceAt(e.high+1);
-}
-
-void ExtractSkolemizer::storeExtract(TNode var, unsigned high, unsigned low) {
- Assert(var.getMetaKind() == kind::metakind::VARIABLE);
- if (d_varToExtract.find(var) == d_varToExtract.end()) {
- d_varToExtract[var] = ExtractList(utils::getSize(var));
- }
- VarExtractMap::iterator it = d_varToExtract.find(var);
- ExtractList& el = it->second;
- Extract e(high, low);
- el.addExtract(e);
-}
-
-void ExtractSkolemizer::collectExtracts(TNode node, TNodeSet& seen) {
- if (seen.find(node) != seen.end()) {
- return;
- }
-
- if (node.getKind() == kind::BITVECTOR_EXTRACT &&
- node[0].getMetaKind() == kind::metakind::VARIABLE) {
- unsigned high = utils::getExtractHigh(node);
- unsigned low = utils::getExtractLow(node);
- TNode var = node[0];
- storeExtract(var, high, low);
- seen.insert(node);
- return;
- }
-
- if (node.getNumChildren() == 0)
- return;
-
- for (unsigned i = 0; i < node.getNumChildren(); ++i) {
- collectExtracts(node[i], seen);
- }
- seen.insert(node);
-}
-
-ExtractSkolemizer::ExtractSkolemizer(theory::SubstitutionMap* modelMap)
- : d_emptyContext()
- , d_varToExtract()
- , d_modelMap(modelMap)
- , d_skolemSubst(&d_emptyContext)
- , d_skolemSubstRev(&d_emptyContext)
-{}
-
-ExtractSkolemizer::~ExtractSkolemizer() {
-}
-
-Node mergeExplanations(const std::vector<Node>& expls) {
- TNodeSet literals;
- for (unsigned i = 0; i < expls.size(); ++i) {
- TNode expl = expls[i];
- Assert(expl.getType().isBoolean());
- if (expl.getKind() == kind::AND) {
- for (const TNode& child : expl)
- {
- if (child == utils::mkTrue()) continue;
- literals.insert(child);
- }
- } else if (expl != utils::mkTrue()) {
- literals.insert(expl);
- }
- }
-
- if (literals.size() == 0) {
- return utils::mkTrue();
- }else if (literals.size() == 1) {
- return *literals.begin();
- }
-
- NodeBuilder nb(kind::AND);
-
- for (TNodeSet::const_iterator it = literals.begin(); it!= literals.end(); ++it) {
- nb << *it;
- }
- return nb;
-}
-
-Node mergeExplanations(TNode expl1, TNode expl2) {
- std::vector<Node> expls;
- expls.push_back(expl1);
- expls.push_back(expl2);
- return mergeExplanations(expls);
-}
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Mathias Preiner, Tim King
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Algebraic solver.
- */
-
-#include "cvc5_private.h"
-
-#pragma once
-
-#include <unordered_map>
-#include <unordered_set>
-
-#include "theory/bv/bv_subtheory.h"
-#include "theory/bv/slicer.h"
-#include "theory/substitutions.h"
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-class AlgebraicSolver;
-
-Node mergeExplanations(TNode expl1, TNode expl2);
-Node mergeExplanations(const std::vector<Node>& expls);
-
-/**
- * Non-context dependent substitution with explanations.
- *
- */
-class SubstitutionEx
-{
- struct SubstitutionElement
- {
- Node to;
- Node reason;
- SubstitutionElement() : to(), reason() {}
-
- SubstitutionElement(TNode t, TNode r) : to(t), reason(r) {}
- };
-
- struct SubstitutionStackElement
- {
- TNode node;
- bool childrenAdded;
- SubstitutionStackElement(TNode n, bool ca = false)
- : node(n), childrenAdded(ca)
- {
- }
- };
-
- typedef std::unordered_map<Node, SubstitutionElement> Substitutions;
- typedef std::unordered_map<Node, SubstitutionElement> SubstitutionsCache;
-
- Substitutions d_substitutions;
- SubstitutionsCache d_cache;
- bool d_cacheInvalid;
- theory::SubstitutionMap* d_modelMap;
-
- Node getReason(TNode node) const;
- bool hasCache(TNode node) const;
- Node getCache(TNode node) const;
- void storeCache(TNode from, TNode to, Node rason);
- Node internalApply(TNode node);
-
- public:
- SubstitutionEx(theory::SubstitutionMap* modelMap);
- /**
- * Returnst true if the substitution map did not contain from.
- *
- * @param from
- * @param to
- * @param reason
- *
- * @return
- */
- bool addSubstitution(TNode from, TNode to, TNode reason);
- Node apply(TNode node);
- Node explain(TNode node) const;
-};
-
-/**
- * In-processing worklist element, id keeps track of
- * original assertion.
- *
- */
-struct WorklistElement
-{
- Node node;
- unsigned id;
- WorklistElement(Node n, unsigned i) : node(n), id(i) {}
- WorklistElement() : node(), id(-1) {}
-};
-
-typedef std::unordered_map<Node, Node> NodeNodeMap;
-typedef std::unordered_map<Node, unsigned> NodeIdMap;
-typedef std::unordered_set<TNode> TNodeSet;
-
-class ExtractSkolemizer
-{
- struct Extract
- {
- unsigned high;
- unsigned low;
- Extract(unsigned h, unsigned l) : high(h), low(l) {}
- };
-
- struct ExtractList
- {
- Base base;
- std::vector<Extract> extracts;
- ExtractList(unsigned bitwidth) : base(bitwidth), extracts() {}
- ExtractList() : base(1), extracts() {}
- void addExtract(Extract& e);
- };
- typedef std::unordered_map<Node, ExtractList> VarExtractMap;
- context::Context d_emptyContext;
- VarExtractMap d_varToExtract;
- theory::SubstitutionMap* d_modelMap;
- theory::SubstitutionMap d_skolemSubst;
- theory::SubstitutionMap d_skolemSubstRev;
-
- void storeSkolem(TNode node, TNode skolem);
- void storeExtract(TNode var, unsigned high, unsigned low);
- void collectExtracts(TNode node, TNodeSet& seen);
- Node skolemize(TNode);
- Node unSkolemize(TNode);
-
- Node mkSkolem(Node node);
-
- public:
- ExtractSkolemizer(theory::SubstitutionMap* modelMap);
- void skolemize(std::vector<WorklistElement>&);
- void unSkolemize(std::vector<WorklistElement>&);
- ~ExtractSkolemizer();
-};
-
-class BVQuickCheck;
-class QuickXPlain;
-
-/**
- * AlgebraicSolver
- */
-class AlgebraicSolver : public SubtheorySolver
-{
- struct Statistics
- {
- IntStat d_numCallstoCheck;
- IntStat d_numSimplifiesToTrue;
- IntStat d_numSimplifiesToFalse;
- IntStat d_numUnsat;
- IntStat d_numSat;
- IntStat d_numUnknown;
- TimerStat d_solveTime;
- ValueStat<double> d_useHeuristic;
- Statistics();
- };
-
- std::unique_ptr<SubstitutionMap> d_modelMap;
- std::unique_ptr<BVQuickCheck> d_quickSolver;
- context::CDO<bool> d_isComplete;
- context::CDO<bool>
- d_isDifficult; /**< flag to indicate whether the current assertions
- contain expensive BV operators */
-
- unsigned long d_budget;
- std::vector<Node> d_explanations; /**< explanations for assertions indexed by
- assertion id */
- TNodeSet d_inputAssertions; /**< assertions in current context (for debugging
- purposes only) */
- NodeIdMap d_ids; /**< map from assertions to ids */
- uint64_t d_numSolved;
- uint64_t d_numCalls;
-
- /** separate quickXplain module as it can reuse the current SAT solver */
- std::unique_ptr<QuickXPlain> d_quickXplain;
-
- Statistics d_statistics;
- bool useHeuristic();
- void setConflict(TNode conflict);
- bool isSubstitutableIn(TNode node, TNode in);
- bool checkExplanation(TNode expl);
- void storeExplanation(TNode expl);
- void storeExplanation(unsigned id, TNode expl);
- /**
- * Apply substitutions and rewriting to the worklist assertions to a fixpoint.
- * Subsitutions learned store in subst.
- *
- * @param worklist
- * @param subst
- */
- void processAssertions(std::vector<WorklistElement>& worklist,
- SubstitutionEx& subst);
- /**
- * Attempt to solve the equation in fact, and if successful
- * add a substitution to subst.
- *
- * @param fact equation we are trying to solve
- * @param reason the reason in terms of original assertions
- * @param subst substitution map
- *
- * @return true if added a substitution to subst
- */
- bool solve(TNode fact, TNode reason, SubstitutionEx& subst);
- /**
- * Run a SAT solver on the given facts with the given budget.
- * Sets the isComplete flag and conflict accordingly.
- *
- * @param facts
- *
- * @return true if no conflict was detected.
- */
- bool quickCheck(std::vector<Node>& facts);
-
- public:
- AlgebraicSolver(context::Context* c, BVSolverLayered* bv);
- ~AlgebraicSolver();
-
- void preRegister(TNode node) override {}
- bool check(Theory::Effort e) override;
- void explain(TNode literal, std::vector<TNode>& assumptions) override
- {
- Unreachable() << "AlgebraicSolver does not propagate.\n";
- }
- EqualityStatus getEqualityStatus(TNode a, TNode b) override;
- bool collectModelValues(TheoryModel* m,
- const std::set<Node>& termSet) override;
- Node getModelValue(TNode node) override;
- bool isComplete() override;
- void assertFact(TNode fact) override;
-};
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Aina Niemetz, Dejan Jovanovic
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Algebraic solver.
- */
-
-#include "theory/bv/bv_subtheory_bitblast.h"
-
-#include "decision/decision_attributes.h"
-#include "options/bv_options.h"
-#include "options/decision_options.h"
-#include "smt/smt_statistics_registry.h"
-#include "theory/bv/abstraction.h"
-#include "theory/bv/bitblast/lazy_bitblaster.h"
-#include "theory/bv/bv_quick_check.h"
-#include "theory/bv/bv_solver_layered.h"
-#include "theory/bv/theory_bv_utils.h"
-
-using namespace std;
-using namespace cvc5::context;
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-BitblastSolver::BitblastSolver(context::Context* c, BVSolverLayered* bv)
- : SubtheorySolver(c, bv),
- d_bitblaster(new TLazyBitblaster(c, bv, "theory::bv::lazy")),
- d_bitblastQueue(c),
- d_statistics(),
- d_validModelCache(c, true),
- d_lemmaAtomsQueue(c),
- d_useSatPropagation(options::bitvectorPropagate()),
- d_abstractionModule(NULL),
- d_quickCheck(),
- d_quickXplain()
-{
- if (options::bitvectorQuickXplain())
- {
- d_quickCheck.reset(new BVQuickCheck("bb", bv));
- d_quickXplain.reset(new QuickXPlain("bb", d_quickCheck.get()));
- }
-}
-
-BitblastSolver::~BitblastSolver() {}
-
-BitblastSolver::Statistics::Statistics()
- : d_numCallstoCheck(smtStatisticsRegistry().registerInt(
- "theory::bv::BitblastSolver::NumCallsToCheck")),
- d_numBBLemmas(smtStatisticsRegistry().registerInt(
- "theory::bv::BitblastSolver::NumTimesLemmasBB"))
-{
-}
-
-void BitblastSolver::setAbstraction(AbstractionModule* abs) {
- d_abstractionModule = abs;
- d_bitblaster->setAbstraction(abs);
-}
-
-void BitblastSolver::preRegister(TNode node) {
- if ((node.getKind() == kind::EQUAL ||
- node.getKind() == kind::BITVECTOR_ULT ||
- node.getKind() == kind::BITVECTOR_ULE ||
- node.getKind() == kind::BITVECTOR_SLT ||
- node.getKind() == kind::BITVECTOR_SLE) &&
- !d_bitblaster->hasBBAtom(node)) {
- CodeTimer weightComputationTime(d_bv->d_statistics.d_weightComputationTimer);
- d_bitblastQueue.push_back(node);
- if ((options::decisionUseWeight() || options::decisionThreshold() != 0) &&
- !node.hasAttribute(decision::DecisionWeightAttr())) {
- node.setAttribute(decision::DecisionWeightAttr(),computeAtomWeight(node));
- }
- }
-}
-
-uint64_t BitblastSolver::computeAtomWeight(TNode node) {
- NodeSet seen;
- return d_bitblaster->computeAtomWeight(node, seen);
-}
-
-void BitblastSolver::explain(TNode literal, std::vector<TNode>& assumptions) {
- d_bitblaster->explain(literal, assumptions);
-}
-
-void BitblastSolver::bitblastQueue() {
- while (!d_bitblastQueue.empty()) {
- TNode atom = d_bitblastQueue.front();
- d_bitblastQueue.pop();
- Debug("bv-bitblast-queue") << "BitblastSolver::bitblastQueue (" << atom << ")\n";
- if (options::bvAbstraction() &&
- d_abstractionModule->isLemmaAtom(atom)) {
- // don't bit-blast lemma atoms
- continue;
- }
- if( !utils::isBitblastAtom(atom) ){
- continue;
- }
- Debug("bitblast-queue") << "Bitblasting atom " << atom <<"\n";
- {
- TimerStat::CodeTimer codeTimer(d_bitblaster->d_statistics.d_bitblastTimer);
- d_bitblaster->bbAtom(atom);
- }
- }
-}
-
-bool BitblastSolver::check(Theory::Effort e)
-{
- Debug("bv-bitblast") << "BitblastSolver::check (" << e << ")\n";
- Assert(options::bitblastMode() == options::BitblastMode::LAZY);
-
- ++(d_statistics.d_numCallstoCheck);
-
- Debug("bv-bitblast-debug") << "...process queue" << std::endl;
- //// Lazy bit-blasting
- // bit-blast enqueued nodes
- bitblastQueue();
-
- // Processing assertions
- while (!done())
- {
- TNode fact = get();
- d_validModelCache = false;
- Debug("bv-bitblast") << " fact " << fact << ")\n";
-
- if (options::bvAbstraction())
- {
- // skip atoms that are the result of abstraction lemmas
- if (d_abstractionModule->isLemmaAtom(fact))
- {
- d_lemmaAtomsQueue.push_back(fact);
- continue;
- }
- }
- // skip facts involving integer equalities (from bv2nat)
- if (!utils::isBitblastAtom(fact))
- {
- continue;
- }
-
- if (!d_bv->inConflict()
- && (!d_bv->wasPropagatedBySubtheory(fact)
- || d_bv->getPropagatingSubtheory(fact) != SUB_BITBLAST))
- {
- // Some atoms have not been bit-blasted yet
- d_bitblaster->bbAtom(fact);
- // Assert to sat
- bool ok = d_bitblaster->assertToSat(fact, d_useSatPropagation);
- if (!ok)
- {
- std::vector<TNode> conflictAtoms;
- d_bitblaster->getConflict(conflictAtoms);
- setConflict(utils::mkAnd(conflictAtoms));
- return false;
- }
- }
- }
-
- Debug("bv-bitblast-debug") << "...do propagation" << std::endl;
- // We need to ensure we are fully propagated, so propagate now
- if (d_useSatPropagation)
- {
- d_bv->spendResource(Resource::BvPropagationStep);
- bool ok = d_bitblaster->propagate();
- if (!ok)
- {
- std::vector<TNode> conflictAtoms;
- d_bitblaster->getConflict(conflictAtoms);
- setConflict(utils::mkAnd(conflictAtoms));
- return false;
- }
- }
-
- // Solving
- Debug("bv-bitblast-debug") << "...do solving" << std::endl;
- if (e == Theory::EFFORT_FULL)
- {
- Assert(!d_bv->inConflict());
- Debug("bitvector::bitblaster")
- << "BitblastSolver::addAssertions solving. \n";
- bool ok = d_bitblaster->solve();
- if (!ok)
- {
- std::vector<TNode> conflictAtoms;
- d_bitblaster->getConflict(conflictAtoms);
- Node conflict = utils::mkAnd(conflictAtoms);
- setConflict(conflict);
- return false;
- }
- }
-
- Debug("bv-bitblast-debug") << "...do abs bb" << std::endl;
- if (options::bvAbstraction() && e == Theory::EFFORT_FULL
- && d_lemmaAtomsQueue.size())
- {
- // bit-blast lemma atoms
- while (!d_lemmaAtomsQueue.empty())
- {
- TNode lemma_atom = d_lemmaAtomsQueue.front();
- d_lemmaAtomsQueue.pop();
- if (!utils::isBitblastAtom(lemma_atom))
- {
- continue;
- }
- d_bitblaster->bbAtom(lemma_atom);
- // Assert to sat and check for conflicts
- bool ok = d_bitblaster->assertToSat(lemma_atom, d_useSatPropagation);
- if (!ok)
- {
- std::vector<TNode> conflictAtoms;
- d_bitblaster->getConflict(conflictAtoms);
- setConflict(utils::mkAnd(conflictAtoms));
- return false;
- }
- }
-
- Assert(!d_bv->inConflict());
- bool ok = d_bitblaster->solve();
- if (!ok)
- {
- std::vector<TNode> conflictAtoms;
- d_bitblaster->getConflict(conflictAtoms);
- Node conflict = utils::mkAnd(conflictAtoms);
- setConflict(conflict);
- ++(d_statistics.d_numBBLemmas);
- return false;
- }
- }
-
-
- return true;
-}
-
-EqualityStatus BitblastSolver::getEqualityStatus(TNode a, TNode b) {
- return d_bitblaster->getEqualityStatus(a, b);
-}
-
-bool BitblastSolver::collectModelValues(TheoryModel* m,
- const std::set<Node>& termSet)
-{
- return d_bitblaster->collectModelValues(m, termSet);
-}
-
-Node BitblastSolver::getModelValue(TNode node)
-{
- if (d_bv->d_invalidateModelCache.get()) {
- d_bitblaster->invalidateModelCache();
- }
- d_bv->d_invalidateModelCache.set(false);
- Node val = d_bitblaster->getTermModel(node, true);
- return val;
-}
-
-void BitblastSolver::setConflict(TNode conflict)
-{
- Node final_conflict = conflict;
- if (options::bitvectorQuickXplain() &&
- conflict.getKind() == kind::AND) {
- // std::cout << "Original conflict " << conflict.getNumChildren() << "\n";
- final_conflict = d_quickXplain->minimizeConflict(conflict);
- //std::cout << "Minimized conflict " << final_conflict.getNumChildren() << "\n";
- }
- d_bv->setConflict(final_conflict);
-}
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Mathias Preiner, Dejan Jovanovic
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Algebraic solver.
- */
-
-#include "cvc5_private.h"
-
-#pragma once
-
-#include <unordered_map>
-
-#include "theory/bv/bv_subtheory.h"
-
-namespace cvc5 {
-
-namespace theory {
-namespace bv {
-
-class TLazyBitblaster;
-class AbstractionModule;
-class BVQuickCheck;
-class QuickXPlain;
-
-/**
- * BitblastSolver
- */
-class BitblastSolver : public SubtheorySolver
-{
- struct Statistics
- {
- IntStat d_numCallstoCheck;
- IntStat d_numBBLemmas;
- Statistics();
- };
- /** Bitblaster */
- std::unique_ptr<TLazyBitblaster> d_bitblaster;
-
- /** Nodes that still need to be bit-blasted */
- context::CDQueue<TNode> d_bitblastQueue;
- Statistics d_statistics;
-
- typedef std::unordered_map<Node, Node> NodeMap;
- NodeMap d_modelCache;
- context::CDO<bool> d_validModelCache;
-
- /** Queue for bit-blasting lemma atoms only in full check if we are sat */
- context::CDQueue<TNode> d_lemmaAtomsQueue;
- bool d_useSatPropagation;
- AbstractionModule* d_abstractionModule;
- std::unique_ptr<BVQuickCheck> d_quickCheck;
- std::unique_ptr<QuickXPlain> d_quickXplain;
- // Node getModelValueRec(TNode node);
- void setConflict(TNode conflict);
-
- public:
- BitblastSolver(context::Context* c, BVSolverLayered* bv);
- ~BitblastSolver();
-
- void preRegister(TNode node) override;
- bool check(Theory::Effort e) override;
- void explain(TNode literal, std::vector<TNode>& assumptions) override;
- EqualityStatus getEqualityStatus(TNode a, TNode b) override;
- bool collectModelValues(TheoryModel* m,
- const std::set<Node>& termSet) override;
- Node getModelValue(TNode node) override;
- bool isComplete() override { return true; }
- void bitblastQueue();
- void setAbstraction(AbstractionModule* module);
- uint64_t computeAtomWeight(TNode atom);
-};
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Andrew Reynolds, Liana Hadarean, Aina Niemetz
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Algebraic solver.
- */
-
-#include "theory/bv/bv_subtheory_core.h"
-
-#include "expr/skolem_manager.h"
-#include "options/bv_options.h"
-#include "options/smt_options.h"
-#include "smt/smt_statistics_registry.h"
-#include "theory/bv/bv_solver_layered.h"
-#include "theory/bv/theory_bv_utils.h"
-#include "theory/ext_theory.h"
-#include "theory/theory_model.h"
-#include "util/rational.h"
-
-using namespace std;
-using namespace cvc5;
-using namespace cvc5::context;
-using namespace cvc5::theory;
-using namespace cvc5::theory::bv;
-using namespace cvc5::theory::bv::utils;
-
-CoreSolver::CoreSolver(context::Context* c, BVSolverLayered* bv)
- : SubtheorySolver(c, bv),
- d_notify(*this),
- d_isComplete(c, true),
- d_lemmaThreshold(16),
- d_preregisterCalled(false),
- d_checkCalled(false),
- d_bv(bv),
- d_reasons(c)
-{
-}
-
-CoreSolver::~CoreSolver() {}
-
-bool CoreSolver::needsEqualityEngine(EeSetupInfo& esi)
-{
- esi.d_notify = &d_notify;
- esi.d_name = "theory::bv::ee";
- return true;
-}
-
-void CoreSolver::finishInit()
-{
- // use the parent's equality engine, which may be the one we allocated above
- d_equalityEngine = d_bv->d_bv.getEqualityEngine();
-
- // The kinds we are treating as function application in congruence
- d_equalityEngine->addFunctionKind(kind::BITVECTOR_CONCAT, true);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_AND);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_OR);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_XOR);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_NOT);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_NAND);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_NOR);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_XNOR);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_COMP);
- d_equalityEngine->addFunctionKind(kind::BITVECTOR_MULT, true);
- d_equalityEngine->addFunctionKind(kind::BITVECTOR_ADD, true);
- d_equalityEngine->addFunctionKind(kind::BITVECTOR_EXTRACT, true);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_SUB);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_NEG);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_UDIV);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_UREM);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_SDIV);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_SREM);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_SMOD);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_SHL);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_LSHR);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_ASHR);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_ULT);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_ULE);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_UGT);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_UGE);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_SLT);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_SLE);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_SGT);
- // d_equalityEngine->addFunctionKind(kind::BITVECTOR_SGE);
- d_equalityEngine->addFunctionKind(kind::BITVECTOR_TO_NAT);
- d_equalityEngine->addFunctionKind(kind::INT_TO_BITVECTOR);
-}
-
-void CoreSolver::preRegister(TNode node) {
- d_preregisterCalled = true;
- if (node.getKind() == kind::EQUAL) {
- d_equalityEngine->addTriggerPredicate(node);
- } else {
- d_equalityEngine->addTerm(node);
- }
-}
-
-
-void CoreSolver::explain(TNode literal, std::vector<TNode>& assumptions) {
- bool polarity = literal.getKind() != kind::NOT;
- TNode atom = polarity ? literal : literal[0];
- if (atom.getKind() == kind::EQUAL) {
- d_equalityEngine->explainEquality(atom[0], atom[1], polarity, assumptions);
- } else {
- d_equalityEngine->explainPredicate(atom, polarity, assumptions);
- }
-}
-
-bool CoreSolver::check(Theory::Effort e) {
- Trace("bitvector::core") << "CoreSolver::check \n";
-
- d_bv->d_im.spendResource(Resource::TheoryCheckStep);
-
- d_checkCalled = true;
- Assert(!d_bv->inConflict());
- ++(d_statistics.d_numCallstoCheck);
- bool ok = true;
- std::vector<Node> core_eqs;
- TNodeBoolMap seen;
- while (! done()) {
- TNode fact = get();
- if (d_isComplete && !isCompleteForTerm(fact, seen)) {
- d_isComplete = false;
- }
-
- // only reason about equalities
- if (fact.getKind() == kind::EQUAL || (fact.getKind() == kind::NOT && fact[0].getKind() == kind::EQUAL)) {
- ok = assertFactToEqualityEngine(fact, fact);
- } else {
- ok = assertFactToEqualityEngine(fact, fact);
- }
- if (!ok)
- return false;
- }
-
- if (Theory::fullEffort(e) && isComplete()) {
- buildModel();
- }
-
- return true;
-}
-
-void CoreSolver::buildModel()
-{
- Debug("bv-core") << "CoreSolver::buildModel() \n";
- NodeManager* nm = NodeManager::currentNM();
- d_modelValues.clear();
- TNodeSet constants;
- TNodeSet constants_in_eq_engine;
- // collect constants in equality engine
- eq::EqClassesIterator eqcs_i = eq::EqClassesIterator(d_equalityEngine);
- while (!eqcs_i.isFinished())
- {
- TNode repr = *eqcs_i;
- if (repr.getKind() == kind::CONST_BITVECTOR)
- {
- // must check if it's just the constant
- eq::EqClassIterator it(repr, d_equalityEngine);
- if (!(++it).isFinished() || true)
- {
- constants.insert(repr);
- constants_in_eq_engine.insert(repr);
- }
- }
- ++eqcs_i;
- }
-
- // build repr to value map
-
- eqcs_i = eq::EqClassesIterator(d_equalityEngine);
- while (!eqcs_i.isFinished())
- {
- TNode repr = *eqcs_i;
- ++eqcs_i;
-
- if (!repr.isVar() && repr.getKind() != kind::CONST_BITVECTOR
- && !d_bv->isSharedTerm(repr))
- {
- continue;
- }
-
- TypeNode type = repr.getType();
- if (type.isBitVector() && repr.getKind() != kind::CONST_BITVECTOR)
- {
- Debug("bv-core-model") << " processing " << repr << "\n";
- // we need to assign a value for it
- TypeEnumerator te(type);
- Node val;
- do
- {
- val = *te;
- ++te;
- // Debug("bv-core-model") << " trying value " << val << "\n";
- // Debug("bv-core-model") << " is in set? " << constants.count(val) <<
- // "\n"; Debug("bv-core-model") << " enumerator done? " <<
- // te.isFinished() << "\n";
- } while (constants.count(val) != 0 && !(te.isFinished()));
-
- if (te.isFinished() && constants.count(val) != 0)
- {
- // if we cannot enumerate anymore values we just return the lemma
- // stating that at least two of the representatives are equal.
- std::vector<TNode> representatives;
- representatives.push_back(repr);
-
- for (TNodeSet::const_iterator it = constants_in_eq_engine.begin();
- it != constants_in_eq_engine.end();
- ++it)
- {
- TNode constant = *it;
- if (utils::getSize(constant) == utils::getSize(repr))
- {
- representatives.push_back(constant);
- }
- }
- for (ModelValue::const_iterator it = d_modelValues.begin();
- it != d_modelValues.end();
- ++it)
- {
- representatives.push_back(it->first);
- }
- std::vector<Node> equalities;
- for (unsigned i = 0; i < representatives.size(); ++i)
- {
- for (unsigned j = i + 1; j < representatives.size(); ++j)
- {
- TNode a = representatives[i];
- TNode b = representatives[j];
- if (a.getKind() == kind::CONST_BITVECTOR
- && b.getKind() == kind::CONST_BITVECTOR)
- {
- Assert(a != b);
- continue;
- }
- if (utils::getSize(a) == utils::getSize(b))
- {
- equalities.push_back(nm->mkNode(kind::EQUAL, a, b));
- }
- }
- }
- // better off letting the SAT solver split on values
- if (equalities.size() > d_lemmaThreshold)
- {
- d_isComplete = false;
- return;
- }
-
- if (equalities.size() == 0)
- {
- Debug("bv-core") << " lemma: true (no equalities)" << std::endl;
- }
- else
- {
- Node lemma = utils::mkOr(equalities);
- d_bv->lemma(lemma);
- Debug("bv-core") << " lemma: " << lemma << std::endl;
- }
- return;
- }
-
- Debug("bv-core-model") << " " << repr << " => " << val << "\n";
- constants.insert(val);
- d_modelValues[repr] = val;
- }
- }
-}
-
-bool CoreSolver::assertFactToEqualityEngine(TNode fact, TNode reason) {
- // Notify the equality engine
- if (!d_bv->inConflict()
- && (!d_bv->wasPropagatedBySubtheory(fact)
- || d_bv->getPropagatingSubtheory(fact) != SUB_CORE))
- {
- Debug("bv-slicer-eq") << "CoreSolver::assertFactToEqualityEngine fact=" << fact << endl;
- // Debug("bv-slicer-eq") << " reason=" << reason << endl;
- bool negated = fact.getKind() == kind::NOT;
- TNode predicate = negated ? fact[0] : fact;
- if (predicate.getKind() == kind::EQUAL) {
- if (negated) {
- // dis-equality
- d_equalityEngine->assertEquality(predicate, false, reason);
- } else {
- // equality
- d_equalityEngine->assertEquality(predicate, true, reason);
- }
- } else {
- // Adding predicate if the congruence over it is turned on
- if (d_equalityEngine->isFunctionKind(predicate.getKind()))
- {
- d_equalityEngine->assertPredicate(predicate, !negated, reason);
- }
- }
- }
-
- // checking for a conflict
- if (d_bv->inConflict())
- {
- return false;
- }
- return true;
-}
-
-bool CoreSolver::NotifyClass::eqNotifyTriggerPredicate(TNode predicate, bool value) {
- Debug("bitvector::core") << "NotifyClass::eqNotifyTriggerPredicate(" << predicate << ", " << (value ? "true" : "false" ) << ")" << std::endl;
- if (value) {
- return d_solver.storePropagation(predicate);
- }
- return d_solver.storePropagation(predicate.notNode());
-}
-
-bool CoreSolver::NotifyClass::eqNotifyTriggerTermEquality(TheoryId tag, TNode t1, TNode t2, bool value) {
- Debug("bitvector::core") << "NotifyClass::eqNotifyTriggerTermMerge(" << t1 << ", " << t2 << ")" << std::endl;
- if (value) {
- return d_solver.storePropagation(t1.eqNode(t2));
- } else {
- return d_solver.storePropagation(t1.eqNode(t2).notNode());
- }
-}
-
-void CoreSolver::NotifyClass::eqNotifyConstantTermMerge(TNode t1, TNode t2) {
- d_solver.conflict(t1, t2);
-}
-
-bool CoreSolver::storePropagation(TNode literal) {
- return d_bv->storePropagation(literal, SUB_CORE);
-}
-
-void CoreSolver::conflict(TNode a, TNode b) {
- std::vector<TNode> assumptions;
- d_equalityEngine->explainEquality(a, b, true, assumptions);
- Node conflict = flattenAnd(assumptions);
- d_bv->setConflict(conflict);
-}
-
-bool CoreSolver::isCompleteForTerm(TNode term, TNodeBoolMap& seen) {
- return utils::isEqualityTerm(term, seen);
-}
-
-bool CoreSolver::collectModelValues(TheoryModel* m,
- const std::set<Node>& termSet)
-{
- if (Debug.isOn("bitvector-model")) {
- context::CDQueue<Node>::const_iterator it = d_assertionQueue.begin();
- for (; it!= d_assertionQueue.end(); ++it) {
- Debug("bitvector-model")
- << "CoreSolver::collectModelValues (assert " << *it << ")\n";
- }
- }
- if (isComplete()) {
- Debug("bitvector-model") << "CoreSolver::collectModelValues complete.";
- for (ModelValue::const_iterator it = d_modelValues.begin(); it != d_modelValues.end(); ++it) {
- Node a = it->first;
- Node b = it->second;
- Debug("bitvector-model") << "CoreSolver::collectModelValues modelValues "
- << a << " => " << b << ")\n";
- if (!m->assertEquality(a, b, true))
- {
- return false;
- }
- }
- }
- return true;
-}
-
-Node CoreSolver::getModelValue(TNode var) {
- Debug("bitvector-model") << "CoreSolver::getModelValue (" << var <<")";
- Assert(isComplete());
- TNode repr = d_equalityEngine->getRepresentative(var);
- Node result = Node();
- if (repr.getKind() == kind::CONST_BITVECTOR) {
- result = repr;
- } else if (d_modelValues.find(repr) == d_modelValues.end()) {
- // it may be a shared term that never gets asserted
- // result is just Null
- Assert(d_bv->isSharedTerm(var));
- } else {
- result = d_modelValues[repr];
- }
- Debug("bitvector-model") << " => " << result <<"\n";
- return result;
-}
-
-EqualityStatus CoreSolver::getEqualityStatus(TNode a, TNode b)
-{
- if (d_equalityEngine->areEqual(a, b))
- {
- // The terms are implied to be equal
- return EQUALITY_TRUE;
- }
- if (d_equalityEngine->areDisequal(a, b, false))
- {
- // The terms are implied to be dis-equal
- return EQUALITY_FALSE;
- }
- return EQUALITY_UNKNOWN;
-}
-
-bool CoreSolver::hasTerm(TNode node) const
-{
- return d_equalityEngine->hasTerm(node);
-}
-void CoreSolver::addTermToEqualityEngine(TNode node)
-{
- d_equalityEngine->addTerm(node);
-}
-
-CoreSolver::Statistics::Statistics()
- : d_numCallstoCheck(smtStatisticsRegistry().registerInt(
- "theory::bv::CoreSolver::NumCallsToCheck"))
-{
-}
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Andrew Reynolds, Liana Hadarean, Mathias Preiner
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Algebraic solver.
- */
-
-#include "cvc5_private.h"
-
-#pragma once
-
-#include <unordered_map>
-#include <unordered_set>
-
-#include "context/cdhashset.h"
-#include "theory/bv/bv_subtheory.h"
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-/**
- * Bitvector equality solver
- */
-class CoreSolver : public SubtheorySolver {
- typedef std::unordered_map<TNode, Node> ModelValue;
- typedef std::unordered_map<TNode, bool> TNodeBoolMap;
- typedef std::unordered_set<TNode> TNodeSet;
-
- struct Statistics {
- IntStat d_numCallstoCheck;
- Statistics();
- };
-
- // NotifyClass: handles call-back from congruence closure module
- class NotifyClass : public eq::EqualityEngineNotify {
- CoreSolver& d_solver;
-
- public:
- NotifyClass(CoreSolver& solver): d_solver(solver) {}
- bool eqNotifyTriggerPredicate(TNode predicate, bool value) override;
- bool eqNotifyTriggerTermEquality(TheoryId tag,
- TNode t1,
- TNode t2,
- bool value) override;
- void eqNotifyConstantTermMerge(TNode t1, TNode t2) override;
- void eqNotifyNewClass(TNode t) override {}
- void eqNotifyMerge(TNode t1, TNode t2) override {}
- void eqNotifyDisequal(TNode t1, TNode t2, TNode reason) override {}
- };
-
-
- /** The notify class for d_equalityEngine */
- NotifyClass d_notify;
-
- /** Store a propagation to the bv solver */
- bool storePropagation(TNode literal);
-
- /** Store a conflict from merging two constants */
- void conflict(TNode a, TNode b);
-
- context::CDO<bool> d_isComplete;
- unsigned d_lemmaThreshold;
-
- bool d_preregisterCalled;
- bool d_checkCalled;
-
- /** Pointer to the parent theory solver that owns this */
- BVSolverLayered* d_bv;
- /** Pointer to the equality engine of the parent */
- eq::EqualityEngine* d_equalityEngine;
-
- /** To make sure we keep the explanations */
- context::CDHashSet<Node> d_reasons;
- ModelValue d_modelValues;
- void buildModel();
- bool assertFactToEqualityEngine(TNode fact, TNode reason);
- bool isCompleteForTerm(TNode term, TNodeBoolMap& seen);
- Statistics d_statistics;
-
- public:
- CoreSolver(context::Context* c, BVSolverLayered* bv);
- ~CoreSolver();
- bool needsEqualityEngine(EeSetupInfo& esi);
- void finishInit();
- bool isComplete() override { return d_isComplete; }
- void preRegister(TNode node) override;
- bool check(Theory::Effort e) override;
- void explain(TNode literal, std::vector<TNode>& assumptions) override;
- bool collectModelValues(TheoryModel* m,
- const std::set<Node>& termSet) override;
- Node getModelValue(TNode var) override;
- EqualityStatus getEqualityStatus(TNode a, TNode b) override;
- bool hasTerm(TNode node) const;
- void addTermToEqualityEngine(TNode node);
-};
-
-}
-}
-} // namespace cvc5
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Aina Niemetz, Andrew Reynolds
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Algebraic solver.
- */
-
-#include "theory/bv/bv_subtheory_inequality.h"
-
-#include "options/smt_options.h"
-#include "smt/smt_statistics_registry.h"
-#include "theory/bv/bv_solver_layered.h"
-#include "theory/bv/theory_bv_utils.h"
-#include "theory/rewriter.h"
-#include "theory/theory_model.h"
-
-using namespace std;
-using namespace cvc5;
-using namespace cvc5::context;
-using namespace cvc5::theory;
-using namespace cvc5::theory::bv;
-using namespace cvc5::theory::bv::utils;
-
-bool InequalitySolver::check(Theory::Effort e) {
- Debug("bv-subtheory-inequality") << "InequalitySolveR::check("<< e <<")\n";
- TimerStat::CodeTimer inequalityTimer(d_statistics.d_solveTime);
- ++(d_statistics.d_numCallstoCheck);
- d_bv->spendResource(Resource::TheoryCheckStep);
-
- bool ok = true;
- while (!done() && ok) {
- TNode fact = get();
- Debug("bv-subtheory-inequality") << " "<< fact <<"\n";
- if (fact.getKind() == kind::EQUAL) {
- TNode a = fact[0];
- if( a.getType().isBitVector() ){
- TNode b = fact[1];
- ok = addInequality(a, b, false, fact);
- if (ok)
- ok = addInequality(b, a, false, fact);
- }
- } else if (fact.getKind() == kind::NOT && fact[0].getKind() == kind::EQUAL) {
- TNode a = fact[0][0];
- if( a.getType().isBitVector() ){
- TNode b = fact[0][1];
- ok = d_inequalityGraph.addDisequality(a, b, fact);
- }
- }
- if (fact.getKind() == kind::NOT && fact[0].getKind() == kind::BITVECTOR_ULE) {
- TNode a = fact[0][1];
- TNode b = fact[0][0];
- ok = addInequality(a, b, true, fact);
- // propagate
- // NodeManager *nm = NodeManager::currentNM();
- // if (d_bv->isSharedTerm(a) && d_bv->isSharedTerm(b)) {
- // Node neq = nm->mkNode(kind::NOT, nm->mkNode(kind::EQUAL, a, b));
- // d_bv->storePropagation(neq, SUB_INEQUALITY);
- // d_explanations[neq] = fact;
- // }
- } else if (fact.getKind() == kind::NOT && fact[0].getKind() == kind::BITVECTOR_ULT) {
- TNode a = fact[0][1];
- TNode b = fact[0][0];
- ok = addInequality(a, b, false, fact);
- } else if (fact.getKind() == kind::BITVECTOR_ULT) {
- TNode a = fact[0];
- TNode b = fact[1];
- ok = addInequality(a, b, true, fact);
- // propagate
- // if (d_bv->isSharedTerm(a) && d_bv->isSharedTerm(b)) {
- // Node neq = nm->mkNode(kind::NOT, nm->mkNode(kind::EQUAL, a, b));
- // d_bv->storePropagation(neq, SUB_INEQUALITY);
- // d_explanations[neq] = fact;
- // }
- } else if (fact.getKind() == kind::BITVECTOR_ULE) {
- TNode a = fact[0];
- TNode b = fact[1];
- ok = addInequality(a, b, false, fact);
- }
- }
-
- if (!ok) {
- std::vector<TNode> conflict;
- d_inequalityGraph.getConflict(conflict);
- Node confl = utils::flattenAnd(conflict);
- d_bv->setConflict(confl);
- Debug("bv-subtheory-inequality") << "InequalitySolver::conflict: "<< confl <<"\n";
- return false;
- }
-
- if (isComplete() && Theory::fullEffort(e)) {
- // make sure all the disequalities we didn't split on are still satisifed
- // and split on the ones that are not
- std::vector<Node> lemmas;
- d_inequalityGraph.checkDisequalities(lemmas);
- for(unsigned i = 0; i < lemmas.size(); ++i) {
- d_bv->lemma(lemmas[i]);
- }
- }
- Debug("bv-subtheory-inequality") << "InequalitySolver done. ";
- return true;
-}
-
-EqualityStatus InequalitySolver::getEqualityStatus(TNode a, TNode b)
-{
- if (!isComplete()) return EQUALITY_UNKNOWN;
-
- NodeManager* nm = NodeManager::currentNM();
- Node a_lt_b = nm->mkNode(kind::BITVECTOR_ULT, a, b);
- Node b_lt_a = nm->mkNode(kind::BITVECTOR_ULT, b, a);
-
- // if an inequality containing the terms has been asserted then we know
- // the equality is false
- if (d_assertionSet.contains(a_lt_b) || d_assertionSet.contains(b_lt_a))
- {
- return EQUALITY_FALSE;
- }
-
- if (!d_inequalityGraph.hasValueInModel(a)
- || !d_inequalityGraph.hasValueInModel(b))
- {
- return EQUALITY_UNKNOWN;
- }
-
- // TODO: check if this disequality is entailed by inequalities via
- // transitivity
-
- BitVector a_val = d_inequalityGraph.getValueInModel(a);
- BitVector b_val = d_inequalityGraph.getValueInModel(b);
-
- if (a_val == b_val)
- {
- return EQUALITY_TRUE_IN_MODEL;
- }
- else
- {
- return EQUALITY_FALSE_IN_MODEL;
- }
-}
-
-void InequalitySolver::assertFact(TNode fact) {
- d_assertionQueue.push_back(fact);
- d_assertionSet.insert(fact);
- if (!isInequalityOnly(fact)) {
- d_isComplete = false;
- }
-}
-
-bool InequalitySolver::isInequalityOnly(TNode node) {
- if (node.getKind() == kind::NOT) {
- node = node[0];
- }
-
- if (node.getAttribute(IneqOnlyComputedAttribute())) {
- return node.getAttribute(IneqOnlyAttribute());
- }
-
- if (node.getKind() != kind::EQUAL &&
- node.getKind() != kind::BITVECTOR_ULT &&
- node.getKind() != kind::BITVECTOR_ULE &&
- node.getKind() != kind::CONST_BITVECTOR &&
- node.getKind() != kind::SELECT &&
- node.getKind() != kind::STORE &&
- node.getMetaKind() != kind::metakind::VARIABLE) {
- // not worth caching
- return false;
- }
- bool res = true;
- for (unsigned i = 0; res && i < node.getNumChildren(); ++i) {
- res = res && isInequalityOnly(node[i]);
- }
- node.setAttribute(IneqOnlyComputedAttribute(), true);
- node.setAttribute(IneqOnlyAttribute(), res);
- return res;
-}
-
-void InequalitySolver::explain(TNode literal, std::vector<TNode>& assumptions) {
- Assert(d_explanations.find(literal) != d_explanations.end());
- TNode explanation = d_explanations[literal];
- assumptions.push_back(explanation);
- Debug("bv-inequality-explain") << "InequalitySolver::explain " << literal << " with " << explanation <<"\n";
-}
-
-void InequalitySolver::propagate(Theory::Effort e) { Assert(false); }
-bool InequalitySolver::collectModelValues(TheoryModel* m,
- const std::set<Node>& termSet)
-{
- Debug("bitvector-model") << "InequalitySolver::collectModelValues \n";
- std::vector<Node> model;
- d_inequalityGraph.getAllValuesInModel(model);
- for (unsigned i = 0; i < model.size(); ++i) {
- Assert(model[i].getKind() == kind::EQUAL);
- if (!m->assertEquality(model[i][0], model[i][1], true))
- {
- return false;
- }
- }
- return true;
-}
-
-Node InequalitySolver::getModelValue(TNode var) {
- Assert(isInequalityOnly(var));
- Debug("bitvector-model") << "InequalitySolver::getModelValue (" << var <<")";
- Assert(isComplete());
- Node result = Node();
- if (!d_inequalityGraph.hasValueInModel(var)) {
- Assert(d_bv->isSharedTerm(var));
- } else {
- BitVector val = d_inequalityGraph.getValueInModel(var);
- result = utils::mkConst(val);
- }
- Debug("bitvector-model") << " => " << result <<"\n";
- return result;
-}
-
-void InequalitySolver::preRegister(TNode node) {
- Kind kind = node.getKind();
- if (kind == kind::EQUAL ||
- kind == kind::BITVECTOR_ULE ||
- kind == kind::BITVECTOR_ULT) {
- d_ineqTerms.insert(node[0]);
- d_ineqTerms.insert(node[1]);
- }
-}
-
-bool InequalitySolver::addInequality(TNode a, TNode b, bool strict, TNode fact)
-{
- bool ok = d_inequalityGraph.addInequality(a, b, strict, fact);
- if (!ok || !strict) return ok;
-
- Node one = utils::mkConst(utils::getSize(a), 1);
- Node a_plus_one = Rewriter::rewrite(
- NodeManager::currentNM()->mkNode(kind::BITVECTOR_ADD, a, one));
- if (d_ineqTerms.find(a_plus_one) != d_ineqTerms.end())
- {
- ok = d_inequalityGraph.addInequality(a_plus_one, b, false, fact);
- }
- return ok;
-}
-
-InequalitySolver::Statistics::Statistics()
- : d_numCallstoCheck(smtStatisticsRegistry().registerInt(
- "theory::bv::inequality::NumCallsToCheck")),
- d_solveTime(smtStatisticsRegistry().registerTimer(
- "theory::bv::inequality::SolveTime"))
-{
-}
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Mathias Preiner, Liana Hadarean, Aina Niemetz
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Algebraic solver.
- */
-
-#include "cvc5_private.h"
-
-#ifndef CVC5__THEORY__BV__BV_SUBTHEORY__INEQUALITY_H
-#define CVC5__THEORY__BV__BV_SUBTHEORY__INEQUALITY_H
-
-#include <unordered_set>
-
-#include "context/cdhashset.h"
-#include "expr/attribute.h"
-#include "theory/bv/bv_inequality_graph.h"
-#include "theory/bv/bv_subtheory.h"
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-/** Cache for InequalitySolver::isInequalityOnly() */
-struct IneqOnlyAttributeId
-{
-};
-typedef expr::Attribute<IneqOnlyAttributeId, bool> IneqOnlyAttribute;
-
-/** Whether the above has been computed yet or not for an expr */
-struct IneqOnlyComputedAttributeId
-{
-};
-typedef expr::Attribute<IneqOnlyComputedAttributeId, bool>
- IneqOnlyComputedAttribute;
-
-class InequalitySolver : public SubtheorySolver
-{
- struct Statistics
- {
- IntStat d_numCallstoCheck;
- TimerStat d_solveTime;
- Statistics();
- };
-
- context::CDHashSet<Node> d_assertionSet;
- InequalityGraph d_inequalityGraph;
- context::CDHashMap<Node, TNode> d_explanations;
- context::CDO<bool> d_isComplete;
- typedef std::unordered_set<Node> NodeSet;
- NodeSet d_ineqTerms;
- bool isInequalityOnly(TNode node);
- bool addInequality(TNode a, TNode b, bool strict, TNode fact);
- Statistics d_statistics;
-
- public:
- InequalitySolver(context::Context* c,
- context::Context* u,
- BVSolverLayered* bv)
- : SubtheorySolver(c, bv),
- d_assertionSet(c),
- d_inequalityGraph(c, u),
- d_explanations(c),
- d_isComplete(c, true),
- d_ineqTerms(),
- d_statistics()
- {
- }
-
- bool check(Theory::Effort e) override;
- void propagate(Theory::Effort e) override;
- void explain(TNode literal, std::vector<TNode>& assumptions) override;
- bool isComplete() override { return d_isComplete; }
- bool collectModelValues(TheoryModel* m,
- const std::set<Node>& termSet) override;
- Node getModelValue(TNode var) override;
- EqualityStatus getEqualityStatus(TNode a, TNode b) override;
- void assertFact(TNode fact) override;
- void preRegister(TNode node) override;
-};
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
-
-#endif /* CVC5__THEORY__BV__BV_SUBTHEORY__INEQUALITY_H */
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Aina Niemetz
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Bitvector theory.
- */
-#include "theory/bv/slicer.h"
-
-#include <sstream>
-
-#include "theory/bv/theory_bv_utils.h"
-#include "theory/rewriter.h"
-
-using namespace std;
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-/**
- * Base
- *
- */
-Base::Base(uint32_t size)
- : d_size(size),
- d_repr(size/32 + (size % 32 == 0? 0 : 1), 0)
-{
- Assert(d_size > 0);
-}
-
-void Base::sliceAt(Index index)
-{
- Index vector_index = index / 32;
- if (vector_index == d_repr.size())
- return;
-
- Index int_index = index % 32;
- uint32_t bit_mask = 1u << int_index;
- d_repr[vector_index] = d_repr[vector_index] | bit_mask;
-}
-
-bool Base::isCutPoint (Index index) const
-{
- // there is an implicit cut point at the end and begining of the bv
- if (index == d_size || index == 0)
- return true;
-
- Index vector_index = index / 32;
- Assert(vector_index < d_size);
- Index int_index = index % 32;
- uint32_t bit_mask = 1u << int_index;
-
- return (bit_mask & d_repr[vector_index]) != 0;
-}
-
-std::string Base::debugPrint() const {
- std::ostringstream os;
- os << "[";
- bool first = true;
- for (int i = d_size - 1; i >= 0; --i) {
- if (isCutPoint(i)) {
- if (first)
- first = false;
- else
- os <<"| ";
-
- os << i ;
- }
- }
- os << "]";
- return os.str();
-}
-
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
+++ /dev/null
-/******************************************************************************
- * Top contributors (to current version):
- * Liana Hadarean, Mathias Preiner, Andrew Reynolds
- *
- * This file is part of the cvc5 project.
- *
- * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
- * in the top-level source directory and their institutional affiliations.
- * All rights reserved. See the file COPYING in the top-level source
- * directory for licensing information.
- * ****************************************************************************
- *
- * Bitvector theory.
- */
-
-#include "cvc5_private.h"
-
-#ifndef CVC5__THEORY__BV__SLICER_BV_H
-#define CVC5__THEORY__BV__SLICER_BV_H
-
-#include <string>
-#include <vector>
-#include "util/index.h"
-
-namespace cvc5 {
-namespace theory {
-namespace bv {
-
-/**
- * Base
- *
- */
-class Base {
- Index d_size;
- std::vector<uint32_t> d_repr;
-public:
- Base(Index size);
- void sliceAt(Index index);
- bool isCutPoint(Index index) const;
- std::string debugPrint() const;
- bool operator==(const Base& other) const {
- if (other.d_size != d_size) return false;
- for (unsigned i = 0; i < d_repr.size(); ++i) {
- if (d_repr[i] != other.d_repr[i])
- return false;
- }
- return true;
- }
-};
-
-} // namespace bv
-} // namespace theory
-} // namespace cvc5
-
-#endif /* CVC5__THEORY__BV__SLICER_BV_H */
#include "smt/smt_statistics_registry.h"
#include "theory/bv/bv_solver_bitblast.h"
#include "theory/bv/bv_solver_bitblast_internal.h"
-#include "theory/bv/bv_solver_layered.h"
#include "theory/bv/theory_bv_rewrite_rules_normalization.h"
#include "theory/bv/theory_bv_rewrite_rules_simplification.h"
#include "theory/bv/theory_bv_utils.h"
#include "theory/ee_setup_info.h"
#include "theory/trust_substitutions.h"
+#include "theory/uf/equality_engine.h"
namespace cvc5 {
namespace theory {
d_internal.reset(new BVSolverBitblast(env, &d_state, d_im, d_pnm));
break;
- case options::BVSolver::LAYERED:
- d_internal.reset(new BVSolverLayered(
- env, *this, context(), userContext(), d_pnm, name));
- break;
-
default:
AlwaysAssert(options().bv.bvSolver == options::BVSolver::BITBLAST_INTERNAL);
d_internal.reset(
d_internal->ppStaticLearn(in, learned);
}
-bool TheoryBV::applyAbstraction(const std::vector<Node>& assertions,
- std::vector<Node>& new_assertions)
-{
- return d_internal->applyAbstraction(assertions, new_assertions);
-}
-
Node TheoryBV::getValue(TNode node)
{
if (d_invalidateModelCache.get())
EqualityStatus getEqualityStatus(TNode a, TNode b) override;
- /** Called by abstraction preprocessing pass. */
- bool applyAbstraction(const std::vector<Node>& assertions,
- std::vector<Node>& new_assertions);
-
private:
void notifySharedTerm(TNode t) override;
regress0/bv/bug440.smtv1.smt2
regress0/bv/bug733.smt2
regress0/bv/bug734.smt2
- regress0/bv/bv-abstr-bug.smt2
regress0/bv/bv-abstr-bug2.smt2
regress0/bv/bv-int-collapse1.smt2
regress0/bv/bv-int-collapse2.smt2
regress1/bv/issue3776.smt2
regress1/bv/issue3958.smt2
regress1/bv/min-pp-rewrite-error.smt2
- regress1/bv/test-bv-abstraction.smt2
regress1/bv/unsound1.smt2
regress1/bvdiv2.smt2
regress1/cee-bug0909-dd-scope.smt2
+++ /dev/null
-; COMMAND-LINE: --bv-abstraction --bitblast=eager
-;
-; BV-abstraction should not be applied
-(set-logic QF_BV)
-(set-info :status sat)
-(declare-const a Bool)
-(declare-const b Bool)
-(declare-const c Bool)
-(declare-const d Bool)
-(assert
- (or
- (and a b)
- (and c d)
- )
-)
-(check-sat)
-; COMMAND-LINE: --bv-intro-pow2 --no-check-unsat-cores --bv-solver=layered
+; COMMAND-LINE: --bv-intro-pow2 --no-check-unsat-cores
(set-info :smt-lib-version 2.6)
(set-logic QF_BV)
(set-info :status unsat)
-; COMMAND-LINE: --no-bv-eq-solver
; EXPECT: sat
(set-logic QF_ALL)
(declare-fun x () (_ BitVec 1))
(assert (= (_ bv0 1) ((_ int2bv 1) (bv2nat x))))
-(check-sat)
\ No newline at end of file
+(check-sat)
+++ /dev/null
-; COMMAND-LINE: --bv-abstraction
-(set-logic QF_BV)
-(set-info :status sat)
-(declare-fun x0 () (_ BitVec 8))
-(declare-fun x1 () (_ BitVec 8))
-(declare-fun y0 () (_ BitVec 8))
-(declare-fun y1 () (_ BitVec 8))
-(declare-fun y2 () (_ BitVec 8))
-(assert
- (or
- (= x0 (bvadd (bvmul (_ bv2 8) y0) y1))
- (= x0 (bvadd (bvmul (_ bv2 8) y1) y2))
- (= x0 (bvadd (bvmul (_ bv2 8) y2) y0))
- )
-)
-(assert
- (or
- (= x1 (bvadd (bvadd (bvmul (_ bv3 8) y0) (bvmul (_ bv2 8) x0)) (_ bv5 8)))
- (= x1 (bvadd (bvadd (bvmul (_ bv3 8) y1) (bvmul (_ bv2 8) x0)) (_ bv5 8)))
- (= x1 (bvadd (bvadd (bvmul (_ bv3 8) x0) (bvmul (_ bv2 8) y2)) (_ bv5 8)))
- )
-)
-(check-sat)
-(exit)
#include "context/context.h"
#include "expr/node.h"
#include "test_smt.h"
-#include "theory/bv/bitblast/eager_bitblaster.h"
-#include "theory/bv/bv_solver_layered.h"
+#include "theory/bv/theory_bv_utils.h"
#include "theory/theory.h"
#include "theory/theory_engine.h"
{
};
-TEST_F(TestTheoryWhiteBv, bitblaster_core)
-{
- d_slvEngine->setLogic("QF_BV");
-
- d_slvEngine->setOption("bitblast", "eager");
- d_slvEngine->setOption("bv-solver", "layered");
- d_slvEngine->setOption("incremental", "false");
- // Notice that this unit test uses the theory engine of a created SMT
- // engine d_slvEngine. We must ensure that d_slvEngine is properly initialized
- // via the following call, which constructs its underlying theory engine.
- d_slvEngine->finishInit();
- TheoryBV* tbv = dynamic_cast<TheoryBV*>(
- d_slvEngine->getTheoryEngine()->d_theoryTable[THEORY_BV]);
- BVSolverLayered* bvsl = dynamic_cast<BVSolverLayered*>(tbv->d_internal.get());
- std::unique_ptr<EagerBitblaster> bb(
- new EagerBitblaster(bvsl, d_slvEngine->getContext()));
-
- Node x = d_nodeManager->mkVar("x", d_nodeManager->mkBitVectorType(16));
- Node y = d_nodeManager->mkVar("y", d_nodeManager->mkBitVectorType(16));
- Node x_plus_y = d_nodeManager->mkNode(kind::BITVECTOR_ADD, x, y);
- Node one = d_nodeManager->mkConst<BitVector>(BitVector(16, 1u));
- Node x_shl_one = d_nodeManager->mkNode(kind::BITVECTOR_SHL, x, one);
- Node eq = d_nodeManager->mkNode(kind::EQUAL, x_plus_y, x_shl_one);
- Node not_x_eq_y = d_nodeManager->mkNode(
- kind::NOT, d_nodeManager->mkNode(kind::EQUAL, x, y));
-
- bb->bbFormula(eq);
- bb->bbFormula(not_x_eq_y);
-
- ASSERT_EQ(bb->solve(), false);
-}
-
TEST_F(TestTheoryWhiteBv, mkUmulo)
{
d_slvEngine->setOption("incremental", "true");
projects / cvc5.git / commitdiff