pax_global_header 0000666 0000000 0000000 00000000064 14501267155 0014520 g ustar 00root root 0000000 0000000 52 comment=a9305c2f58e46b7f39fed4e9cf63d61d0dae7ef7
cadical-rel-1.7.4/ 0000775 0000000 0000000 00000000000 14501267155 0013671 5 ustar 00root root 0000000 0000000 cadical-rel-1.7.4/.clang-format 0000664 0000000 0000000 00000000145 14501267155 0016244 0 ustar 00root root 0000000 0000000 AlignEscapedNewlines: DontAlign
ColumnLimit: 76
SpaceBeforeParens: Always
SpaceAfterCStyleCast: true
cadical-rel-1.7.4/.gitignore 0000664 0000000 0000000 00000000017 14501267155 0015657 0 ustar 00root root 0000000 0000000 build
makefile
cadical-rel-1.7.4/BUILD.md 0000664 0000000 0000000 00000010516 14501267155 0015055 0 ustar 00root root 0000000 0000000 # CaDiCaL Build
Use `./configure && make` to configure and build `cadical` in the default
`build` sub-directory.
This will also build the library `libcadical.a` as well as the model based
tester `mobical`:
build/cadical
build/mobical
build/libcadical.a
The header file of the library is in
src/cadical.hpp
The build process requires GNU make. Using the generated `makefile` with
GNU make compiles separate object files, which can be cached (for instance
with `ccache`). In order to force parallel build you can use the '-j'
option either for 'configure' or with 'make'. If the environment variable
'MAKEFLAGS' is set, e.g., 'MAKEFLAGS=-j ./configure', the same effect
is achieved and the generated makefile will use those flags.
Options
-------
You might want to check out options of `./configure -h`, such as
./configure -c # include assertion checking code
./configure -l # include code to really see what the solver is doing
./configure -a # both above and in addition `-g` for debugging.
You can easily use multiple build directories, e.g.,
mkdir debug; cd debug; ../configure -g; make
which compiles and builds a debugging version in the sub-directory `debug`,
since `-g` was specified as parameter to `configure`. The object files,
the library and the binaries are all independent of those in the default
build directory `build`.
All source files reside in the `src` directory. The library `libcadical.a`
is compiled from all the `.cpp` files except `cadical.cpp` and
`mobical.cpp`, which provide the applications, i.e., the stand alone solver
`cadical` and the model based tester `mobical`.
Manual Build
------------
If you can not or do not want to rely on our `configure` script nor on our
build system based on GNU `make`, then this is easily doable as follows.
mkdir build
cd build
for f in ../src/*.cpp; do g++ -O3 -DNDEBUG -DNBUILD -c $f; done
ar rc libcadical.a `ls *.o | grep -v ical.o`
g++ -o cadical cadical.o -L. -lcadical
g++ -o mobical mobical.o -L. -lcadical
Note that application object files are excluded from the library.
Of course you can use different compilation options as well.
Since `build.hpp` is not generated in this flow the `-DNBUILD` flag is
necessary though, which avoids dependency of `version.cpp` on `build.hpp`.
Consequently you will only get very basic version information compiled into
the library and binaries (guaranteed is in essence just the version number
of the library).
And if you really do not care about compilation time nor caching and just
want to build the solver once manually then the following also works.
g++ -O3 -DNDEBUG -DNBUILD -o cadical `ls *.cpp | grep -v mobical`
Further note that the `configure` script provides some feature checks and
might generate additional compiler flags necessary for compilation. You
might need to set those yourself or just use a modern C++11 compiler.
This manual build process using object files is fast enough in combination
with caching solutions such as `ccache`. But it lacks the ability of our
GNU make solution to run compilation in parallel without additional parallel
process scheduling solutions.
Cross-Compilation
-----------------
We have preliminary support for cross-compilation using MinGW32 (only
tested for a Linux compilation host and Windows-64 target host at this
point).
There are two steps necessary to make this work. First make
sure to be able to execute binaries compiled with the cross-compiler
directly. Otherwise 'configure' does not work automatically and you
have to build manually (as described above).
For instance in order to use `wine` to execute the binaries first install
`wine` which for instance on Ubuntu just requires
sudo apt install wine
Then on Linux you might want to look into the `binfmt_misc` module and
as root register the appropriate interpreter for `DOSWin`.
cd /proc/sys/fs/binfmt_misc
echo ':DOSWin:M::MZ::/usr/bin/wine:' > register
Finally simply tell the `configure` script to use the cross-compiler.
CXX=i686-w64-mingw32-g++ ./configure -static -lpsapi && make cadical
Note the use of '-static', which was necessary for me since by default
`wine` did not find `libstdc++` if dynamically linked. There is also
a dependency on the 'psapi' library. Also `mobical` does not compile with
MinGW32 due to too many Unix dependencies and thus only make 'cadical'.
cadical-rel-1.7.4/CONTRIBUTING 0000664 0000000 0000000 00000000353 14501267155 0015524 0 ustar 00root root 0000000 0000000 At this point we want to keep complete ownership in one hand
to particularly avoid any additional co-authorship claims.
Thus please refrain from generating pull requests. Use the issue
tracker or send email to 'biere@jku.at' instead.
cadical-rel-1.7.4/LICENSE 0000664 0000000 0000000 00000003044 14501267155 0014677 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2016-2021 Armin Biere, Johannes Kepler University Linz, Austria
Copyright (c) 2020-2021 Mathias Fleury, Johannes Kepler University Linz, Austria
Copyright (c) 2020-2021 Nils Froleyks, Johannes Kepler University Linz, Austria
Copyright (c) 2022-2023 Katalin Fazekas, Vienna University of Technology, Austria
Copyright (c) 2021-2023 Armin Biere, University of Freiburg, Germany
Copyright (c) 2021-2023 Mathias Fleury, University of Freiburg, Germany
Copyright (c) 2023 Florian Pollitt, University of Freiburg, Germany
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.
cadical-rel-1.7.4/NEWS.md 0000664 0000000 0000000 00000007620 14501267155 0014774 0 ustar 00root root 0000000 0000000 Version 1.7.4
-------------
- As `fork` and `wait` do not exist on Windows writing compressed files
through `pipe/fork/exec/wait` has to be disabled for Windows cross
compilation to go through. Alternatively one could go back to `popen`
for writing compressed files on Windows which however is not safe and
therefore we simply decided to disable that feature for windows.
Compressed file reading still (and as far we are aware safely) uses
`popen` and thus also compiles for Windows.
Version 1.7.3
-------------
- Replaced the unsafe `popen` approach for compressed file writing
with an explicit `pipe/fork/exec/waitpid` flow and accordingly
removed the `--safe` configuration option again.
Version 1.7.2
-------------
- Configuration option `--safe` disables writing to a file
through `popen` which makes library usage safer.
Version 1.7.1
-------------
- Added support for VeriPB proofs (--lrat --lratveripb).
- Various fixes: LRAT proofs for constrain (which previously were
not traced correctly); internal-external mapping issues for LRAT
(worked for user propagator but now also in combination with LRAT);
further minor bug fixes.
- Added support for LRAT + external propagator in combination.
Version 1.7.0
-------------
- Added native LRAT support.
Version 1.6.0
-------------
- Added IPASIR-UP functions to the API to support external propagation,
external decisions, and clause addition during search.
For more details see the following paper at SAT 2023:
Katalin Fazekas, Aina Niemetz, Mathias Preiner, Markus Kirchweger,
Stefan Szeider and Armin Biere. IPASIR-UP: User Propagators for CDCL.
- During decisions the phase set by 'void phase (int lit)' has now
higher precedence than the initial phase set by options 'phase' and
'forcephase'.
Version 1.5.6
-------------
- Clang formatted all source code (and fixed one failing regression
test by disabling 'otfs' for it).
- Implementing OTFS during conflict analysis (--otfs).
- The last literal set by vivification is instantiated (--vivifyinst).
- more accurate tracking of binary clauses in watch lists by updating
the size in watch lists.
Version 1.5.4
-------------
- Picking highest score literal in assumed clause ('constrain')
and caching of satisfied literal by moving them to the front.
- Added 'bool flippable (int lit)' to API.
- Fixed 'val' to return 'lit' or '-lit' and not just '-1' and '1'.
- Allowing 'fixed' between 'constrain' in 'mobical'.
- Fixed LZMA magic header.
- Added 'bool flip (int lit)' to API.
- Fixed different garbage collection times with and without
clause IDs (with './configure -l' or just './configure').
This solves issue #44 by John Reeves. At the same time
made sure to trigger garbage collection independent on the
number of clause header bytes by relying on the number of
garbage literals instead.
- Fixed 'mmap' usage for FreeBSD (#48 issue of 'yurivict').
- Removed several compiler warnings when using newer compilers,
including gcc-11, gcc-12, clang-14, and clang-15.
- Replaced 'sprintf' by 'snprintf' to avoid warning on MacOS
(thanks to Marijn for bringing this up).
- Assigning a C 'FILE' pointer to 'stdout' during initialization
fails on MacOS and thus separated declaration and initialization.
- Fixed random seed initialization from MAC address issue #47
as used by 'mobical' which produces segmentation faults
(thanks to Sam Bayless for pointing this out).
Version 1.5.2
-------------
- Updates to documentation and copyright.
Version 1.5.2
-------------
- More copyright updates in banner.
- Fixed MinGW cross-compilation (see 'BUILD.md').
Version 1.5.1
-------------
- Fixed copyright and added two regression traces.
Version 1.5.0
-------------
- Added 'constrain' API call described in our FMCAD'21 paper.
- Replaced "`while () push_back ()`" with "`if () resize ()`" idiom
(thanks go to Alexander Smal for pointing this out).
cadical-rel-1.7.4/README.md 0000664 0000000 0000000 00000004443 14501267155 0015155 0 ustar 00root root 0000000 0000000 [](https://opensource.org/licenses/MIT)
CaDiCaL Simplified Satisfiability Solver
===============================================================================
The goal of the development of CaDiCaL was to obtain a CDCL solver,
which is easy to understand and change, while at the same time not being
much slower than other state-of-the-art CDCL solvers.
Originally we wanted to also radically simplify the design and internal data
structures, but that goal was only achieved partially, at least for instance
compared to Lingeling.
However, the code is much better documented and CaDiCaL actually became in
general faster than Lingeling even though it is missing some preprocessors
(mostly parity and cardinality constraint reasoning), which would be crucial
to solve certain instances.
Use `./configure && make` to configure and build `cadical` and the library
`libcadical.a` in the default `build` sub-directory. The header file of
the library is [`src/cadical.hpp`](src/cadical.hpp) and includes an example
for API usage.
See [`BUILD.md`](BUILD.md) for options and more details related to the build
process and [`test/README.md`](test/README.md) for testing the library and
the solver. Since release 1.5.1 we have a [`NEWS.md`](NEWS.md) file.
The solver has the following usage `cadical [ dimacs [ proof ] ]`.
See `cadical -h` for more options.
If you want to cite CaDiCaL please use the solver description in the
latest SAT competition proceedings:
@inproceedings{BiereFazekasFleuryHeisinger-SAT-Competition-2020-solvers,
author = {Armin Biere and Katalin Fazekas and Mathias Fleury and Maximillian Heisinger},
title = {{CaDiCaL}, {Kissat}, {Paracooba}, {Plingeling} and {Treengeling}
Entering the {SAT Competition 2020}},
pages = {51--53},
editor = {Tomas Balyo and Nils Froleyks and Marijn Heule and
Markus Iser and Matti J{\"a}rvisalo and Martin Suda},
booktitle = {Proc.~of {SAT Competition} 2020 -- Solver and Benchmark Descriptions},
volume = {B-2020-1},
series = {Department of Computer Science Report Series B},
publisher = {University of Helsinki},
year = 2020,
}
You might also find more information on CaDiCaL at .
Armin Biere
cadical-rel-1.7.4/VERSION 0000664 0000000 0000000 00000000006 14501267155 0014735 0 ustar 00root root 0000000 0000000 1.7.3
cadical-rel-1.7.4/configure 0000775 0000000 0000000 00000031315 14501267155 0015603 0 ustar 00root root 0000000 0000000 #!/bin/sh
#--------------------------------------------------------------------------#
# Run './configure' to produce a 'makefile' in the 'build' sub-directory or
# in any immediate sub-directory different from the 'src', 'scripts' and
# 'test' directories.
#--------------------------------------------------------------------------#
rm -f configure.log
#--------------------------------------------------------------------------#
# Common default options.
all=no
debug=no
libs=""
logging=no
check=no
competition=no
coverage=no
profile=no
contracts=yes
tracing=yes
unlocked=yes
pedantic=no
options=""
quiet=no
m32=no
#--------------------------------------------------------------------------#
if [ -f ./scripts/colors.sh ]
then
. ./scripts/colors.sh
elif [ -f ../scripts/colors.sh ]
then
. ../scripts/colors.sh
else
BAD=""
HILITE=""
BOLD=""
NORMAL=""
fi
die () {
if [ -f configure.log ]
then
checklog=" (check also 'configure.log')"
else
checklog=""
fi
cecho "${BOLD}configure:${NORMAL} ${BAD}error:${NORMAL} $*${checklog}"
exit 1
}
msg () {
cecho "${BOLD}configure:${NORMAL} $*"
}
# if we can find the 'color.sh' script source it and overwrite color codes
for dir in . ..
do
[ -f $dir/scripts/colors.sh ] || continue
. $dir/scripts/colors.sh || exit 1
break
done
#--------------------------------------------------------------------------#
# Parse and handle command line options.
usage () {
cat << EOF
usage: configure [ ... ]
where ' ' is one of the following
-h|--help print this command line summary
-g|--debug compile with debugging information
-c|--check compile with assertion checking (default for '-g')
-l|--log[ging] include logging code (but disabled by default)
-a|--all short cut for all above, e.g., '-g -l' (thus also '-c')
-q|--quiet exclude message and profiling code (logging too)
-p|--pedantic add '--pedantic' and '-Werror' compilation flag
-s|--symbols add '-ggdb3' (even for optimized compilation)
--coverage compile with '-ftest-coverage -fprofile-arcs' for 'gcov'
--profile compile with '-pg' to profile with 'gprof'
--no-contracts compile without API contract checking code
--no-tracing compile without API call tracing code
--competition configure for the competition
('--quiet', '--no-contracts', '--no-tracing')
-f... pass '-f [=]' options to the makefile
-m32 pass '-m32' to the compiler (compile for 32 bit)
-ggdb3 pass '-ggdb3' to makefile (like '-s')
-O|-O[123] pass '-O' or '-O[123]' to the makefile
-static... pass '-static...' option to makefile
The environment variable CXX can be used to set a different C++
compiler than the default 'g++'. Similarly you can add additional
compilation options by setting CXXFLAGS. For example
CXX=clang++ CXXFLAGS=-fPIC ./configure
will enforce to use 'clang++' as C++ compiler and also produce
position independent code. In order to be shell independent we also
allow to have the following form. Thus for instance
./configure CXX="g++-8" CXXFLAGS="-fPIC -fsanitize=address"
will have the same effect as
CXX="g++-8" ./configure -fPIC -fsanitize=address
The following configuration options might be usefull during porting the
code to a new platform and are usually not necessary to change.
--no-unlocked force compilation without unlocked IO
EOF
exit 0
}
#--------------------------------------------------------------------------#
while [ $# -gt 0 ]
do
case $1 in
-h|--help) usage;;
-a|--all) all=yes;;
-g|--debug) debug=yes;;
-c|--check) check=yes;;
-l|--log|--logging) logging=yes;;
-l*) libs="$libs $1";;
-p|--pedantic) pedantic=yes;;
-q|--quiet) quiet=yes;;
--no-contracts | --no-contract) contracts=no;;
--no-tracing | --no-trace) tracing=no;;
--coverage) coverage=yes;;
--profile) profile=yes;;
--competition) competition=yes;;
--no-unlocked) unlocked=no;;
-m32) options="$options $1";m32=yes;;
-f*|-ggdb3|-O|-O1|-O2|-O3) options="$options $1";;
-s|--symbols) options="$options -ggdb3";;
-static*) options="$options $1";;
CXX=*)
CXX="`expr \"$1\" : 'CXX=\(.*\)'`"
;;
CXXFLAGS=*)
CXXFLAGS="`expr \"$1\" : 'CXXFLAGS=\(.*\)'`"
;;
*) die "invalid option '$1' (try '-h')";;
esac
shift
done
#--------------------------------------------------------------------------#
if [ $quiet = yes ]
then
[ $logging = yes ] && die "can not combine '-q' with '-l'"
fi
if [ $all = yes ]
then
[ $check = yes ] && die "'-a' subsumes '-c'"
[ $debug = yes ] && die "'-a' subsumes '-g'"
[ $logging = yes ] && die "'-a' subsumes '-l'"
check=yes
debug=yes
logging=yes
elif [ $debug = yes ]
then
[ $check = yes ] && die "'-g' subsumes '-c'"
check=yes
fi
#--------------------------------------------------------------------------#
# Generate and enter 'build' directory if not already in sub-directory.
build_in_default_build_sub_directory () {
if [ -d build ]
then
msg "reusing default 'build' directory"
else
mkdir build 2>/dev/null || \
die "failed to generate 'build' directory"
msg "making default 'build' directory"
fi
cd build
msg "building in default ${HILITE}'`pwd`'${NORMAL}"
build=build
}
if [ -f configure -a -f makefile.in -a -d src ]
then
root="`pwd`"
build_in_default_build_sub_directory
elif [ -f ../configure -a -f ../makefile.in -a -d ../src ]
then
cwd="`pwd`"
build=`basename "$cwd"`
root=`dirname "$cwd"`
case x"$build" in
xsrc|xtest|xscripts)
cd ..
build_in_default_build_sub_directory
;;
*)
msg "building in ${HILITE}'$build'${NORMAL} sub-directory"
;;
esac
else
die "call 'configure' from root of CaDiCaL source or a sub-directory"
fi
msg "root directory '$root'"
#--------------------------------------------------------------------------#
src="$root/src"
if [ -d "$src" ]
then
msg "source directory '$src'"
else
die "could not find source director '$src'"
fi
#--------------------------------------------------------------------------#
# Prepare '@CXX@' and '@CXXFLAGS@' parameters for 'makefile.in'
[ x"$CXX" = x ] && CXX=g++
[ x"$CXXFLAGS" = x ] || CXXFLAGS="$CXXFLAGS "
case x"$CXX" in
x*g++*|x*clang++*) CXXFLAGS="${CXXFLAGS}-Wall -Wextra";;
*) CXXFLAGS="${CXXFLAGS}-W";;
esac
if [ $debug = yes ]
then
CXXFLAGS="$CXXFLAGS -g"
else
case x"$CXX" in
x*g++*|x*clang++*) CXXFLAGS="$CXXFLAGS -O3";;
*) CXXFLAGS="$CXXFLAGS -O";;
esac
fi
if [ $m32 = yes ]
then
case x"$CXX" in
x*g++*)
options="$options -mpc64"
msg "forcing portable 64-bit FPU mode ('-mpc64') for '$CXX'"
;;
esac
fi
if [ $competition = yes ]
then
quiet=yes
contracts=no
tracing=no
fi
[ $check = no ] && CXXFLAGS="$CXXFLAGS -DNDEBUG"
[ $logging = yes ] && CXXFLAGS="$CXXFLAGS -DLOGGING"
[ $quiet = yes ] && CXXFLAGS="$CXXFLAGS -DQUIET"
[ $profile = yes ] && CXXFLAGS="$CXXFLAGS -pg"
[ $coverage = yes ] && CXXFLAGS="$CXXFLAGS -ftest-coverage -fprofile-arcs"
if [ $pedantic = yes ]
then
CXXFLAGS="$CXXFLAGS --pedantic -Werror -std=c++11"
case x"$CXX" in
x*g++*|x*clang++*) CXXFLAGS="${CXXFLAGS} -Wp,-D_GLIBCXX_ASSERTIONS"
;;
esac
fi
[ $contracts = no ] && CXXFLAGS="$CXXFLAGS -DNCONTRACTS"
[ $tracing = no ] && CXXFLAGS="$CXXFLAGS -DNTRACING"
CXXFLAGS="$CXXFLAGS$options"
#--------------------------------------------------------------------------#
case x"$CXX" in
x*g++* | x*clang++*) WERROR="-Werror -pedantic";;
*) WERROR="";;
esac
# Check that compilation flags work.
feature=./configure-hello-world
cat < $feature.cpp
#include
int main () { std::cout << "hello world" << std::endl; }
EOF
if $CXX $CXXFLAGS $WERROR -o $feature.exe $feature.cpp 2>>configure.log
then
if [ ! "`$feature.exe 2>>configure.log|tr -d '\r'`" = "hello world" ]
then
die "execution of '$feature.exe' failed"
fi
else
die "test compilation '$feature.cpp'"
fi
#--------------------------------------------------------------------------#
# Since C99/C++11 is becoming the standard newer versions of 'g++' (7.3 for
# instance) discourage certain GCC extensions, particularly the GCC version
# of variadic macros, if the same concept exists in the standard. This
# forced us to replace all GCC style 'ARGS...' macros with '...' and
# '__VA_ARGS__'. Otherwise compiling the library with '--pedantic -Werror'
# would fail (configuration flag '-p'). However, older versions of 'gcc'
# (such as 4.8) would disallow these new forms of macros unless we
# explicitly enforce the new standard with '-std=c++11'. Here we try to
# figure out whether we need that flag. In earlier versions we used
# '-std=c++0x' but due to issues with older MacOS builds we switched to
# '-std=c++11' instead.
feature=./configure-requires-c++11
cat < $feature.cpp
#include
#include
// old variadic macro usage 'ARGS...' / '#ARGS' discouraged in g++-7...
// new variadic macro usage '...' / '__VA_ARGS__' available in C99/C++11
//
#define MACRO(FMT, ...) printf (FMT "\n", __VA_ARGS__)
// we use ranged for loops which became available in gcc 4.6 and for
// the gcc 4.6 as well as 4.8 requires '-std=c++11' too.
//
unsigned f (const std::vector & a) {
unsigned res = 0;
for (auto i : a) res += i;
return res;
}
int main () { MACRO ("%d", 42); return 0; }
EOF
if $CXX $CXXFLAGS $WERROR -o $feature.exe $feature.cpp 2>>configure.log
then
if [ "`$feature.exe 2>>configure.log|tr -d '\r'`" = 42 ]
then
msg "compiler supports all required C99/C++11 extensions"
else
die "checking compilation without '-std=c++11' failed"
fi
else
CXXFLAGS="$CXXFLAGS -std=c++11"
if $CXX $CXXFLAGS -o $feature.exe $feature.cpp 2>>configure.log
then
if [ "`$feature.exe 2>>configure.log|tr -d '\r'`" = 42 ]
then
msg "using '-std=c++11' for all required C99/C++11 extensions"
else
die "checking compilation with '-std=c++11' failed"
fi
else
die "compiler does not support C99/C++11 even with '-std=c++11'"
fi
fi
#--------------------------------------------------------------------------#
# Unlocked IO is much faster but not necessarily supported.
if [ $unlocked = yes ]
then
feature=./configure-have-unlocked-io
cat < $feature.cpp
#include
int main () {
const char * path = "$feature.log";
FILE * file = fopen (path, "w");
if (!file) return 1;
if (putc_unlocked (42, file) != 42) return 1;
if (fclose (file)) return 1;
file = fopen (path, "r");
if (!file) return 1;
if (getc_unlocked (file) != 42) return 1;
if (fclose (file)) return 1;
return 0;
}
EOF
if $CXX $CXXFLAGS -o $feature.exe $feature.cpp 2>>configure.log
then
if $feature.exe
then
msg "unlocked IO with '{putc,getc}_unlocked' seems to work"
else
msg "not using unlocked IO (running '$feature.exe' failed)"
unlocked=no
fi
else
msg "not using unlocked IO (failed to compile '$feature.cpp')"
unlocked=no
fi
else
msg "not using unlocked IO (since '--no-unlocked' specified)"
fi
[ $unlocked = no ] && CXXFLAGS="$CXXFLAGS -DNUNLOCKED"
#--------------------------------------------------------------------------#
# Instantiate '../makefile.in' template to produce 'makefile' in 'build'.
msg "compiling with ${HILITE}'$CXX $CXXFLAGS'${NORMAL}"
rm -f makefile
sed \
-e "2c\\
# This 'makefile' is generated from '../makefile.in'." \
-e "s,@CXX@,$CXX," \
-e "s#@CXXFLAGS@#$CXXFLAGS#" \
-e "s#@LIBS@#$libs#" \
../makefile.in > makefile
msg "generated '$build/makefile' from '../makefile.in'"
#--------------------------------------------------------------------------#
build="`pwd`"
makefile="`dirname "$build"`/makefile"
cat < "$makefile"
CADICALBUILD=$build
all:
\$(MAKE) -C "\$(CADICALBUILD)"
clean:
@if [ -d "\$(CADICALBUILD)" ]; \\
then \\
if [ -f "\$(CADICALBUILD)"/makefile ]; \\
then \\
touch "\$(CADICALBUILD)"/build.hpp; \\
\$(MAKE) -C "\$(CADICALBUILD)" clean; \\
fi; \\
rm -rf "\$(CADICALBUILD)"; \\
fi
rm -f "$src/makefile"
rm -f "$makefile"
test:
\$(MAKE) -C "\$(CADICALBUILD)" test
cadical:
\$(MAKE) -C "\$(CADICALBUILD)" cadical
mobical:
\$(MAKE) -C "\$(CADICALBUILD)" mobical
update:
\$(MAKE) -C "\$(CADICALBUILD)" update
format:
\$(MAKE) -C "\$(CADICALBUILD)" format
.PHONY: all cadical clean mobical test format
EOF
msg "generated '../makefile' as proxy to ..."
msg "... '$build/makefile'"
#--------------------------------------------------------------------------#
if [ -f $src/makefile ]
then
msg "removing '$src/makefile'"
rm -f $src/makefile
fi
msg "linking '$root/makefile'"
ln -s $root/makefile $src/makefile
#--------------------------------------------------------------------------#
msg "now run ${HILITE}'make'${NORMAL} to compile CaDiCaL"
msg "optionally run 'make test'"
cadical-rel-1.7.4/makefile.in 0000664 0000000 0000000 00000005326 14501267155 0016004 0 ustar 00root root 0000000 0000000 #==========================================================================#
# This is a 'makefile.in' template with '@CXX@' and '@CXXFLAGS@' parameters.
# This makefile requires GNU make.
#==========================================================================#
# The '../scripts/make-build-header.sh' script searches for the next two
# lines to figure out the compiler and compilation flags. This information
# is then used to generate corresponding macros in 'build.hpp'.
CXX=@CXX@
CXXFLAGS=@CXXFLAGS@
LIBS=@LIBS@
############################################################################
# It is usually not necessary to change anything below this line! #
############################################################################
APP=cadical.cpp mobical.cpp
SRC=$(sort $(wildcard ../src/*.cpp))
SUB=$(subst ../src/,,$(SRC))
LIB=$(filter-out $(APP),$(SUB))
OBJ=$(LIB:.cpp=.o)
DIR=../$(shell pwd|sed -e 's,.*/,,')
COMPILE=$(CXX) $(CXXFLAGS) -I$(DIR)
#--------------------------------------------------------------------------#
all: libcadical.a cadical mobical
#--------------------------------------------------------------------------#
.SUFFIXES: .cpp .o
%.o: ../src/%.cpp ../src/*.hpp makefile
$(COMPILE) -c $<
#--------------------------------------------------------------------------#
# Application binaries (the stand alone solver 'cadical' and the model based
# tester 'mobical') and the library are the main build targets.
cadical: cadical.o libcadical.a makefile
$(COMPILE) -o $@ $< -L. -lcadical $(LIBS)
mobical: mobical.o libcadical.a makefile $(LIBS)
$(COMPILE) -o $@ $< -L. -lcadical
libcadical.a: $(OBJ) makefile
ar rc $@ $(OBJ)
#--------------------------------------------------------------------------#
# Note that 'build.hpp' is generated and resides in the build directory.
build.hpp: always
../scripts/make-build-header.sh > build.hpp
version.o: build.hpp
update:
../scripts/update-version.sh
#--------------------------------------------------------------------------#
# These two 'C' interfaces include '.h' headers and thus require explicitly
# defined additional dependencies.
ccadical.o: ../src/ccadical.h
ipasir.o: ../src/ipasir.h ../src/ccadical.h
#--------------------------------------------------------------------------#
analyze: all
$(COMPILE) --analyze ../src/*.cpp
format:
clang-format -i ../*/*.[ch]pp
clang-format -i ../*/*.[ch]
clang-format -i ../test/*/*.[ch]pp
clang-format -i ../test/*/*.[ch]
clean:
rm -f *.o *.a cadical mobical makefile build.hpp
rm -f *.gcda *.gcno *.gcov gmon.out
test: all
CADICALBUILD="$(DIR)" $(MAKE) -j1 -C ../test
#--------------------------------------------------------------------------#
.PHONY: all always analyze clean test update format
cadical-rel-1.7.4/scripts/ 0000775 0000000 0000000 00000000000 14501267155 0015360 5 ustar 00root root 0000000 0000000 cadical-rel-1.7.4/scripts/README.md 0000664 0000000 0000000 00000003073 14501267155 0016642 0 ustar 00root root 0000000 0000000 # CaDiCaL Scripts
Scripts needed for the build process
./make-build-header.sh # generates 'build.hpp'
./get-git-id.sh # get GIT id (needed by 'make-build-header.sh')
./update-version.sh # synchronizes VERSION in '../src/version.cpp'
and a script which builds and tests all configurations
./build-and-test-all-configurations.sh
CXX=clang++ ./build-and-test-all-configurations.sh
CXX=g++-4.8 ./build-and-test-all-configurations.sh
where as the code shows the compiler (default `g++`) is specified through
the environment variable `CXX` (as for `../configure`). Then there are
scripts for producing a source release
./make-src-release.sh # archive as 'cadical-VERSION-GITID.tar.xz'
./prepare-sc2021-submission.sh # star-exec format for SAT competition
and scripts for testing and debugging
./generate-embedded-options-default-list.sh # in 'c --opt=val' format
./generate-options-range-list.sh # 'cnfuzz' option file format
./run-cadical-and-check-proof.sh # wrapper to check proofs too
./run-simplifier-and-extend-solution.sh # to check simplifier
./extend-solution.sh # called by previous script
a script to check whether all options are actually used
./check-options-occur.sh
a script to update the example in the `../src/cadical.hpp` header
./update-example-in-cadical-header-file.sh
and finally a script to normalize white space of the source code
./normalize-white-space.sh
The `color.sh` script is used by the `run.sh` scripts in `test`.
cadical-rel-1.7.4/scripts/build-and-test-all-configurations.sh 0000775 0000000 0000000 00000004531 14501267155 0024334 0 ustar 00root root 0000000 0000000 #!/bin/sh
. `dirname $0`/colors.sh || exit 1
############################################################################
die () {
echo "build-and-test-all-configurations.sh: ${BAD}error${NORMAL}: $*" 1>&2
exit 1
}
############################################################################
if [ -f configure ]
then
configure="./configure"
makeoptions=""
elif [ -f ../configure ]
then
configure="../configure"
makeoptions=" -C .."
else
die "Can not find 'configure'."
fi
if [ "$CXX" = "" ]
then
environment=""
else
environment="CXX=$CXX "
fi
if [ ! "$CXXFLAGS" = "" ]
then
[ "$environment" = "" ] || environment="$environment "
environment="${environment}CXXFLAGS=\"$CXXFLAGS\" "
fi
############################################################################
ok=0
run () {
if [ "$*" = "" ]
then
configureoptions=""
description=""
else
configureoptions=" $*"
description="$*"
fi
echo "$environment$configure$configureoptions && make$makeoptions test"
$configure$configureoptions $* >/dev/null 2>&1 && \
make$makeoptions test >/dev/null 2>&1
test $? = 0 || die "Configuration \`$description' failed."
make$makeoptions clean >/dev/null 2>&1
test $? = 0 || die "Cleaning up for \`$description' failed."
ok=`expr $ok + 1`
}
############################################################################
# start with these two for fast fail
run # default configuration (depends on 'MAKEFLAGS'!)
run -p # then check default pedantic first
run -q # library users might want to disable messages
run -q -p # also check '--quiet' pedantically
# now start with the five single options
run -a # actually enables all the four next options below
run -c
run -g
run -l
# all five single options pedantically
run -a -p
run -c -p
run -g -p
run -l -p
# all legal pairs of single options
# ('-a' can not be combined with any of the other options)
# ('-g' can not be combined '-c')
run -c -l
run -c -q
run -g -l
run -g -q
# the same pairs but now with pedantic compilation
run -c -l -p
run -c -q -p
run -g -l -p
run -g -q -p
# finally check that these also work to some extend
run --no-unlocked -q
run --no-unlocked -a -p
run --no-contracts -q
run --no-contracts -a -p
run --no-tracing -q
run --no-tracing -a -p
run -m32 -q
run -m32 -a -p
echo "successfully compiled and tested ${GOOD}${ok}${NORMAL} configurations"
cadical-rel-1.7.4/scripts/check-options-occur.sh 0000775 0000000 0000000 00000000351 14501267155 0021575 0 ustar 00root root 0000000 0000000 #!/bin/sh
sed \
-e '/^[OLQ[A-Z]*(/!d' \
-e 's,^[OLQ[A-Z]*(,,' \
-e 's/,.*//' \
../src/options.hpp | \
while read option
do
grep -q opts.$option ../src/*.hpp ../src/*.cpp && continue
echo "option '$option' not found"
done
cadical-rel-1.7.4/scripts/colors.sh 0000664 0000000 0000000 00000000747 14501267155 0017225 0 ustar 00root root 0000000 0000000 # Use colors if '' is connected to a terminal.
color_echo_options=""
if [ -t 1 ]
then
BAD="\033[1;31m" # bright red
HILITE="\033[32m" # normal green
GOOD="\033[1;32m" # bright green
HIDE="\033[34m" # cyan
BOLD="\033[1m" # bold color
NORMAL="\033[0m" # normal color
if [ x"`echo -e 2>/dev/null`" = x ]
then
color_echo_options=" -e"
fi
else
BAD=""
HILITE=""
GOOD=""
HIDE=""
BOLD=""
NORMAL=""
fi
cecho () {
echo$color_echo_options $*
}
cadical-rel-1.7.4/scripts/extend-solution.sh 0000775 0000000 0000000 00000002416 14501267155 0021063 0 ustar 00root root 0000000 0000000 #!/bin/sh
name=extend-solution.sh
scriptsdir=`dirname $0`
colors=$scriptsdir/colors.sh
if [ -f $colors ]
then
. $colors
else
BAD=""
BOLD=""
NORMAL=""
fi
die () {
echo "${BOLD}$name:${NORMAL} ${BAD}error:${NORMAL} $*" 1>&2
exit 1
}
[ $# -eq 2 ] || \
die "expected exactly two arguments"
[ -f $1 ] || \
die "argument '$1' not a file"
[ -f $2 ] || \
die "argument '$2' not a file"
status="`grep '^s' $1|head -1`"
case x"$status" in
x"s SATISFIABLE") ;;
x"s UNSATISFIABLE") echo "s UNSATISFIABLE"; exit 20;;
*) die "not valid 's ...' line found in '$1'";;
esac
(
grep '^v' $1;
awk '{
printf "c"
for (i = 1; $i; i++)
printf " %d", $i
printf "\nw";
for (i++; $i; i++)
printf " %d", $i
printf "\n"
}' $2
) | \
awk '
function abs (i) { return i < 0 ? -i : i }
/^v/{
for (i = 2; i <= NF; i++) {
lit = $i;
idx = abs(lit);
if (idx) a[idx] = lit;
}
}
/^c/{
satisfied = 0
for (i = 2; i <= NF; i++) {
lit = $i;
idx = abs(lit);
tmp = a[idx];
if (lit < 0) tmp = -tmp;
if (tmp > 0) satisfied = 1;
}
}
/^w/{
if (satisfied) next
for (i = 2; i <= NF; i++) {
lit = $i;
idx = abs(lit);
a[idx] = -a[idx];
}
}
END {
print "s SATISFIABLE"
for (i in a)
print "v", a[i]
print "v 0"
}
'
exit 10
cadical-rel-1.7.4/scripts/generate-cubes.sh 0000775 0000000 0000000 00000001254 14501267155 0020612 0 ustar 00root root 0000000 0000000 #!/bin/sh
usage () {
cat <&1
usage: generate-cubes.sh [-h] [ ... ] ]
EOF
exit 0
}
[ "$1" = -h ] && usage
die () {
echo "generate-cubes.sh: error: $*" 1>&2
exit 1
}
[ $# -lt 1 ] && die "expected DIMACS file argument"
output=""
options=""
[ -f "$1" ] || die "first argument is not a DIMACS file"
input="$1"
shift
while [ $# -gt 0 ]
do
case "$1" in
-*) options="$options $1";;
*) exec 1>"$1";;
esac
shift
done
prefix=/tmp/generate-cubes-$$
cleanup () {
rm -f $prefix*
}
trap "cleanup" 2 11
cubes=$prefix.cubes
march_cu $input -o $cubes $options 1>&2 || exit 1
sed -e 's,^p cnf.*,p inccnf,' $input
cat $cubes
cleanup
exit 0
cadical-rel-1.7.4/scripts/generate-embedded-options-default-list.sh 0000775 0000000 0000000 00000000440 14501267155 0025322 0 ustar 00root root 0000000 0000000 #!/bin/sh
cd `dirname $0`
grep 'OPTION( ' ../src/options.hpp | \
sed -e 's,^OPTION( ,,' \
-e 's/,/ /' \
-e 's/,.*//g' | \
awk '{printf "c --%s=%d\n", $1, $2}' | \
grep -v 'check' | \
grep -v 'clim' | \
grep -v 'dlim' | \
grep -v 'extend' | \
grep -v 'learn' | \
grep -v 'witness'
cadical-rel-1.7.4/scripts/generate-options-range-list.sh 0000775 0000000 0000000 00000000706 14501267155 0023250 0 ustar 00root root 0000000 0000000 #!/bin/sh
cd `dirname $0`
egrep '^(OPTION|BCEOPT|SHROPT)\( ' ../src/options.hpp | \
grep -v '\/dev/null |awk '{print $2;exit}'
cadical-rel-1.7.4/scripts/make-build-header.sh 0000775 0000000 0000000 00000005025 14501267155 0021161 0 ustar 00root root 0000000 0000000 #!/bin/sh
#--------------------------------------------------------------------------#
# Used to generate 'build.hpp', which in turn is used in 'version.cpp' to
# print compile time options, compiler version, and source code version.
# If generating 'build.hpp' fails you can still compile 'version.cpp' by
# using the '-DNBUILD' compile time option.
#--------------------------------------------------------------------------#
die () {
echo "make-build-header.sh: error: $*" 1>&2
exit 1
}
warning () {
echo "make-build-header.sh: warning: $*" 1>&2
}
#--------------------------------------------------------------------------#
[ ! -f VERSION -a ! -f ../VERSION ] && \
die "needs to be called from build sub-directory"
[ -f makefile ] || \
warning "could not find 'makefile'"
#--------------------------------------------------------------------------#
# The version.
#
VERSION="`cat ../VERSION`"
if [ x"$VERSION" = x ]
then
warning "could not determine 'VERSION'"
else
echo "#define VERSION \"$VERSION\""
fi
#--------------------------------------------------------------------------#
# The unique GIT hash.
#
IDENTIFIER="`../scripts/get-git-id.sh`"
if [ x"$IDENTIFIER" = x ]
then
warning "could not determine 'IDENTIFIER' (git id)"
else
echo "#define IDENTIFIER \"$IDENTIFIER\""
fi
#--------------------------------------------------------------------------#
# C++ compiler 'CXX' used in 'makefile'.
#
COMPILER="`sed -e '/^CXX=/!d' -e 's,^CXX=,,' makefile 2>/dev/null`"
case x"$COMPILER" in
x*g++* | x*clang++*)
COMPILER="`$COMPILER --version 2>/dev/null|head -1`";;
*) COMPILER="";;
esac
if [ x"$COMPILER" = x ]
then
warning "could not determine 'COMPILER' ('CXX')"
else
echo "#define COMPILER \"$COMPILER\""
fi
#--------------------------------------------------------------------------#
# C++ compiler flags 'CXXFLAGS' used in 'makefile'.
#
FLAGS="`sed -e '/^CXXFLAGS=/!d' -e 's,^CXXFLAGS=,,' makefile 2>/dev/null`"
if [ x"$FLAGS" = x ]
then
warning "could not determine 'FLAGS' ('CXXFLAGS')"
else
echo "#define FLAGS \"$FLAGS\""
fi
#--------------------------------------------------------------------------#
# Use time of executing this script at build time.
#
LC_TIME="en_US" # Avoid umlaut in 'DATE'.
export LC_TIME
# The time and date we compiled the CaDiCaL library.
DATE="`date 2>/dev/null|sed -e 's, *, ,g'`"
OS="`uname -srmn 2>/dev/null`"
DATE="`echo $DATE $OS|sed -e 's,^ *,,' -e 's, *$,,'`"
if [ x"$DATE" = x" " ]
then
warning "could not determine 'DATE' (build date and time)"
else
echo "#define DATE \"$DATE\""
fi
cadical-rel-1.7.4/scripts/make-src-release.sh 0000775 0000000 0000000 00000002236 14501267155 0021042 0 ustar 00root root 0000000 0000000 #!/bin/sh
die () {
echo "make-src-release.sh: error: $*" 1>&2
exit 1
}
cd `dirname $0`/..
[ -d .git ] || \
die "does not seem to be under 'git' control ('.git' not found)"
version="`awk '/define VERSION/{print $4}' src/version.cpp|sed -e 's,",,g'`"
VERSION="`cat VERSION`"
[ "$version" = "$VERSION" ] || \
die "versions '$version' in 'src/version.cpp' and " \
"'$VERSION' in 'VERSION' do not match (run 'scripts/update-version.sh')"
fullgitid="`./scripts/get-git-id.sh`"
gitid="`echo $fullgitid|sed -e 's,^\(.......\).*,\1,'`"
branch=`git branch|grep '^\*'|head -1|awk '{print $2}'`
[ "$branch" = "" ] && die "could not get branch from 'git'"
name=cadical-${version}-${gitid}
[ "$branch" = "master" ] || name="$name-$branch"
dir=/tmp/$name
tar=/tmp/$name.tar.xz
rm -rf $dir
mkdir $dir || exit 1
git archive $branch | tar -x -C $dir
cat >$dir/scripts/get-git-id.sh < $i
rm -f $i~
done
cadical-rel-1.7.4/scripts/prepare-sc2021-submission.sh 0000775 0000000 0000000 00000002234 14501267155 0022457 0 ustar 00root root 0000000 0000000 #!/bin/sh
cd `dirname $0`/..
root=`pwd`
tmp=/tmp/prepare-cadical-sc2021-submission.log
VERSION=`cat VERSION`
rm -f $tmp
##########################################################################
cd $root
./scripts/make-src-release.sh >$tmp || exit 1
tar=`awk '{print $2}' $tmp |sed -e "s,',,g"`
##########################################################################
cd $root
base=cadical-${VERSION}-starexec
dir=/tmp/$base
rm -rf $dir
mkdir $dir
mkdir $dir/bin
mkdir $dir/build
mkdir $dir/archives
cp -a $tar $dir/archives
cat <$dir/build/build.sh
#!/bin/sh
tar xf ../archives/cadical*
mv cadical* cadical
cd cadical
./configure --competition
make test
install -s build/cadical ../../bin/
EOF
chmod 755 $dir/build/build.sh
cat <$dir/starexec_build
#!/bin/sh
cd build
exec ./build.sh
EOF
chmod 755 $dir/starexec_build
cat <$dir/bin/starexec_run_default
#!/bin/sh
exec ./cadical \$1 \$2/proof.out
EOF
chmod 755 $dir/bin/starexec_run_default
description=$dir/starexec_description.txt
grep '^CaDiCaL' README.md|head -1 >$description
cat $description
archive=/tmp/$base.zip
rm -f $archive
cd $dir
zip -r $archive .
cd /tmp/
ls -l $archive
rm -f $tmp
rm -rf $dir/
cadical-rel-1.7.4/scripts/run-cadical-and-check-proof.sh 0000775 0000000 0000000 00000002464 14501267155 0023045 0 ustar 00root root 0000000 0000000 #!/bin/sh
scriptsdir=`dirname $0`
bindir=$scriptsdir/../build
solver=$bindir/cadical
solutionchecker=$bindir/precochk
proofchecker=$bindir/drat-trim
name=run-cadical-and-check-proof.sh
colors=$scriptsdir/colors.sh
if [ -f $colors ]
then
. $colors
else
BAD=""
BOLD=""
HIDE=""
NORMAL=""
fi
die () {
echo "$name: error: $*" 1>&2
exit 1
}
msg () {
echo "${HIDE}c [$name] $*${NORMAL}"
}
[ $# -eq 1 ] || \
die "expected exactly one argument"
msg "input '$1'"
[ -f $solver ] || \
die "can not find '$solver' (build solver first)"
msg "found '$solver'"
[ -f $solutionchecker ] || \
die "can not find '$solutionchecker' (run cnf tests to compile it first)"
msg "found '$solutionchecker'"
[ -f $proofchecker ] || \
die "can not find '$proofchecker' (run cnf tests to compile it first)"
msg "found '$proofchecker'"
prefix=/tmp/run-cadical-and-check-proof-$$
trap "rm -f $prefix*" 2 9 15
msg "$solver $1 $prefix.proof > $prefix.log"
$solver $1 $prefix.proof > $prefix.log
res=$?
msg "solver exit code '$res'"
msg "cat $prefix.log"
cat $prefix.log
case $res in
10)
msg "$solutionchecker $1 $prefix.log"
$solutionchecker $1 $prefix.log || exit 1
;;
20)
msg "$proofchecker $1 $prefix.proof"
$proofchecker $1 $prefix.proof || exit 1
;;
esac
msg "rm -f $prefix*"
rm -f $prefix*
msg "exit $res"
exit $res
cadical-rel-1.7.4/scripts/run-simplifier-and-extend-solution.sh 0000775 0000000 0000000 00000003442 14501267155 0024566 0 ustar 00root root 0000000 0000000 #!/bin/sh
scriptsdir=`dirname $0`
bindir=$scriptsdir/../build
solver=$bindir/cadical
colors=$scriptsdir/colors.sh
extend=$scriptsdir/extend-solution.sh
name=run-simplifier-and-extend-solution.sh
if [ -f $colors ]
then
. $colors
else
BAD=""
BOLD=""
HIDE=""
NORMAL=""
fi
die () {
echo "${BOLD}$name:${NORMAL} ${BAD}error:${NORMAL} $*" 1>&2
exit 1
}
msg () {
echo "${HIDE}c [$name] $*${NORMAL}"
}
input=""
options=""
while [ $# -gt 0 ]
do
case $1 in
-t) options="$1 $2"; shift;;
*)
if [ -f $1 ]
then
[ "$input" ] && die "too many inputs"
input="$1"
else
die "invalid option '$1'"
fi
;;
esac
shift
done
msg "input '$input'"
msg "options '$options'"
[ "$input" ] || die "expected at least one input argument"
[ -f $solver ] || \
die "can not find '$solver' (build solver first)"
msg "found '$solver'"
[ -f $extend ] || \
die "can not find '$extend'"
prefix=/tmp/run-simplifier-and-extend-solution-$$
trap "rm -f $prefix*" 2 9 15
out=$prefix.out
ext=$prefix.ext
log=$prefix.log
msg "$solver $options -n -O1 -c 0 -o $out -e $ext $input > $log"
$solver $options -n -O1 -c 0 -o $out -e $ext $input > $log
res=$?
msg "simplifier exit code '$res'"
msg "sed -e 's,^[vs],c,' -e 's,^c,c [simplifier],' $log"
sed -e 's,^[vs],c,' -e 's,^c,c [simplifier],' $log
msg "$solver $options $out > $log"
$solver $options $out > $log
res=$?
msg "solver exit code '$res'"
msg "sed -e 's,^[vs],c,' -e 's,^c,c [solver],' $log"
sed -e 's,^[vs],c,' -e 's,^c,c [solver],' $log
case $res in
0|10|20) ;;
*) die "unexpected solver exit code '$res'";;
esac
if [ $res = 10 ]
then
msg "$extend $log $ext"
$extend $log $ext
res=$?
msg "extender exit code $res"
elif [ $res = 20 ]
then
echo "s UNSATISFIABLE"
fi
msg "rm -f $prefix*"
rm -f $prefix*
msg "exit $res"
exit $res
cadical-rel-1.7.4/scripts/update-example-in-cadical-header-file.sh 0000775 0000000 0000000 00000001037 14501267155 0024760 0 ustar 00root root 0000000 0000000 #!/bin/sh
echo `dirname $0`
cd `dirname $0`
pwd
. ./colors.sh
new=/tmp/cadical.hpp
old=../src/cadical.hpp
example=../test/api/example.cpp
rm -f $new
sed -e '/solver = new CaDiCaL::Solver/,$d' $old >> $new
sed -e '/solver = new CaDiCaL::Solver/,/delete solver/!d' $example | \
expand | sed -e 's,^,// ,' >> $new
sed -e '1,/delete solver/d' $old >> $new
echo "${HILITE}diff $old $new${NORMAL}"
if diff $old $new
then
echo "${GOOD}no need to update '$old'${NORMAL}"
else
echo "${BAD}cp $new $old${NORMAL}"
cp $new $old
fi
rm -f $new
cadical-rel-1.7.4/scripts/update-version.sh 0000775 0000000 0000000 00000000633 14501267155 0020666 0 ustar 00root root 0000000 0000000 #!/bin/sh
cd `dirname $0`
NEW="`cat ../VERSION`"
OLD="`awk '/define VERSION/{print \$4}' ../src/version.cpp|sed -e 's,\",,g'`"
if [ x"$OLD" = x"$NEW" ]
then
echo "same version '$NEW' in 'VERSION' and '../src/version.cpp'"
else
echo "found new version '$NEW' in '../VERSION'"
echo "updating old version '$OLD' in '../src/version.cpp'"
sed -i -e '/define VERSION/s,".*",'\""$NEW"\", ../src/version.cpp
fi
cadical-rel-1.7.4/src/ 0000775 0000000 0000000 00000000000 14501267155 0014460 5 ustar 00root root 0000000 0000000 cadical-rel-1.7.4/src/README.md 0000664 0000000 0000000 00000001035 14501267155 0015736 0 ustar 00root root 0000000 0000000 This is the source code of the library `libcadical.a` with header
`cadical.hpp`, the stand-alone solver `cadical` (in `cadical.cpp`) and the
model based tester `mobical` (in `mobical.app`).
The `configure` script and link to the `makefile` in the root directory
can be used from within the `src` sub-directory too and then will just work
as if used from the root directory. For instance
./configure && make test
will configure and build in `../build` the default (optimizing)
configuration and if successful then run the test suite.
cadical-rel-1.7.4/src/analyze.cpp 0000664 0000000 0000000 00000107020 14501267155 0016627 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// Code for conflict analysis, i.e., to generate the first UIP clause. The
// main function is 'analyze' below. It further uses 'minimize' to minimize
// the first UIP clause, which is in 'minimize.cpp'. An important side
// effect of conflict analysis is to update the decision queue by bumping
// variables. Similarly analyzed clauses are bumped to mark them as active.
/*------------------------------------------------------------------------*/
void Internal::learn_empty_clause () {
assert (!unsat);
build_chain_for_empty ();
LOG ("learned empty clause");
external->check_learned_empty_clause ();
int64_t id = ++clause_id;
if (proof) {
if (opts.lrat && !opts.lratexternal) {
LOG (lrat_chain, "learned empty clause with proof chain: ");
proof->add_derived_empty_clause (id, lrat_chain);
} else
proof->add_derived_empty_clause (id);
}
unsat = true;
conflict_id = id;
lrat_chain.clear ();
}
void Internal::learn_unit_clause (int lit) {
assert (!unsat);
LOG ("learned unit clause %d", lit);
external->check_learned_unit_clause (lit);
int64_t id = ++clause_id;
const unsigned uidx = vlit (lit);
unit_clauses[uidx] = id;
if (proof) {
if (opts.lrat && !opts.lratexternal) {
LOG (lrat_chain, "learned unit clause with proof chain: ");
proof->add_derived_unit_clause (id, lit, lrat_chain);
} else
proof->add_derived_unit_clause (id, lit);
}
mark_fixed (lit);
}
void Internal::learn_external_propagated_unit_clause (int lit) {
assert (!unsat);
LOG ("assume unit clause %d from external propagator was already checked",
lit);
assert (unit_clauses[vlit (lit)]);
mark_fixed (lit);
}
/*------------------------------------------------------------------------*/
// Move bumped variables to the front of the (VMTF) decision queue. The
// 'bumped' time stamp is updated accordingly. It is used to determine
// whether the 'queue.assigned' pointer has to be moved in 'unassign'.
void Internal::bump_queue (int lit) {
assert (opts.bump);
const int idx = vidx (lit);
if (!links[idx].next)
return;
queue.dequeue (links, idx);
queue.enqueue (links, idx);
assert (stats.bumped != INT64_MAX);
btab[idx] = ++stats.bumped;
LOG ("moved to front variable %d and bumped to %" PRId64 "", idx,
btab[idx]);
if (!vals[idx])
update_queue_unassigned (idx);
}
/*------------------------------------------------------------------------*/
// It would be better to use 'isinf' but there are some historical issues
// with this function. On some platforms it is a macro and even for C++ it
// changed the scope (in pre 5.0 gcc) from '::isinf' to 'std::isinf'. I do
// not want to worry about these strange incompatibilities and thus use the
// same trick as in older solvers (since the MiniSAT team invented EVSIDS)
// and simply put a hard limit here. It is less elegant but easy to port.
static inline bool evsids_limit_hit (double score) {
assert (sizeof (score) == 8); // assume IEEE 754 64-bit double
return score > 1e150; // MAX_DOUBLE is around 1.8e308
}
/*------------------------------------------------------------------------*/
// Classical exponential VSIDS as pioneered by MiniSAT.
void Internal::rescale_variable_scores () {
stats.rescored++;
double divider = score_inc;
for (auto idx : vars) {
const double tmp = stab[idx];
if (tmp > divider)
divider = tmp;
}
PHASE ("rescore", stats.rescored, "rescoring %d variable scores by 1/%g",
max_var, divider);
assert (divider > 0);
double factor = 1.0 / divider;
for (auto idx : vars)
stab[idx] *= factor;
score_inc *= factor;
PHASE ("rescore", stats.rescored,
"new score increment %g after %" PRId64 " conflicts", score_inc,
stats.conflicts);
}
void Internal::bump_variable_score (int lit) {
assert (opts.bump);
int idx = vidx (lit);
double old_score = score (idx);
assert (!evsids_limit_hit (old_score));
double new_score = old_score + score_inc;
if (evsids_limit_hit (new_score)) {
LOG ("bumping %g score of %d hits EVSIDS score limit", old_score, idx);
rescale_variable_scores ();
old_score = score (idx);
assert (!evsids_limit_hit (old_score));
new_score = old_score + score_inc;
}
assert (!evsids_limit_hit (new_score));
LOG ("new %g score of %d", new_score, idx);
score (idx) = new_score;
if (scores.contains (idx))
scores.update (idx);
}
// Important variables recently used in conflict analysis are 'bumped',
void Internal::bump_variable (int lit) {
if (use_scores ())
bump_variable_score (lit);
else
bump_queue (lit);
}
// After every conflict the variable score increment is increased by a
// factor (if we are currently using scores).
void Internal::bump_variable_score_inc () {
assert (use_scores ());
assert (!evsids_limit_hit (score_inc));
double f = 1e3 / opts.scorefactor;
double new_score_inc = score_inc * f;
if (evsids_limit_hit (new_score_inc)) {
LOG ("bumping %g increment by %g hits EVSIDS score limit", score_inc,
f);
rescale_variable_scores ();
new_score_inc = score_inc * f;
}
assert (!evsids_limit_hit (new_score_inc));
LOG ("bumped score increment from %g to %g with factor %g", score_inc,
new_score_inc, f);
score_inc = new_score_inc;
}
/*------------------------------------------------------------------------*/
struct analyze_bumped_rank {
Internal *internal;
analyze_bumped_rank (Internal *i) : internal (i) {}
typedef uint64_t Type;
Type operator() (const int &a) const { return internal->bumped (a); }
};
struct analyze_bumped_smaller {
Internal *internal;
analyze_bumped_smaller (Internal *i) : internal (i) {}
bool operator() (const int &a, const int &b) const {
const auto s = analyze_bumped_rank (internal) (a);
const auto t = analyze_bumped_rank (internal) (b);
return s < t;
}
};
/*------------------------------------------------------------------------*/
void Internal::bump_variables () {
assert (opts.bump);
START (bump);
if (opts.bumpreason)
bump_also_all_reason_literals ();
if (!use_scores ()) {
// Variables are bumped in the order they are in the current decision
// queue. This maintains relative order between bumped variables in
// the queue and seems to work best. We also experimented with
// focusing on variables of the last decision level, but results were
// mixed.
MSORT (opts.radixsortlim, analyzed.begin (), analyzed.end (),
analyze_bumped_rank (this), analyze_bumped_smaller (this));
}
for (const auto &lit : analyzed)
bump_variable (lit);
if (use_scores ())
bump_variable_score_inc ();
STOP (bump);
}
/*------------------------------------------------------------------------*/
// We use the glue time stamp table 'gtab' for fast glue computation.
int Internal::recompute_glue (Clause *c) {
int res = 0;
const int64_t stamp = ++stats.recomputed;
for (const auto &lit : *c) {
int level = var (lit).level;
assert (gtab[level] <= stamp);
if (gtab[level] == stamp)
continue;
gtab[level] = stamp;
res++;
}
return res;
}
// Clauses resolved since the last reduction are marked as 'used', their
// glue is recomputed and they are promoted if the glue shrinks. Note that
// promotion from 'tier3' to 'tier2' will set 'used' to '2'.
inline void Internal::bump_clause (Clause *c) {
LOG (c, "bumping");
unsigned used = c->used;
c->used = 1;
if (c->keep)
return;
if (c->hyper)
return;
if (!c->redundant)
return;
int new_glue = recompute_glue (c);
if (new_glue < c->glue)
promote_clause (c, new_glue);
else if (used && c->glue <= opts.reducetier2glue)
c->used = 2;
}
/*------------------------------------------------------------------------*/
// During conflict analysis literals not seen yet either become part of the
// first unique implication point (UIP) clause (if on lower decision level),
// are dropped (if fixed), or are resolved away (if on the current decision
// level and different from the first UIP). At the same time we update the
// number of seen literals on a decision level. This helps conflict clause
// minimization. The number of seen levels is the glucose level (also
// called 'glue', or 'LBD').
inline void Internal::analyze_literal (int lit, int &open,
int &resolvent_size,
int &antecedent_size) {
assert (lit);
Var &v = var (lit);
Flags &f = flags (lit);
if (!v.level) {
if (f.seen || !opts.lrat || opts.lratexternal)
return;
f.seen = true;
unit_analyzed.push_back (lit);
assert (val (lit) < 0);
const unsigned uidx = vlit (-lit);
uint64_t id = unit_clauses[uidx];
assert (id);
unit_chain.push_back (id);
return;
}
++antecedent_size;
if (f.seen)
return;
f.seen = true;
analyzed.push_back (lit);
assert (val (lit) < 0);
assert (v.level <= level);
assert (v.reason != external_reason);
if (v.level < level)
clause.push_back (lit);
Level &l = control[v.level];
if (!l.seen.count++) {
LOG ("found new level %d contributing to conflict", v.level);
levels.push_back (v.level);
}
if (v.trail < l.seen.trail)
l.seen.trail = v.trail;
++resolvent_size;
LOG ("analyzed literal %d assigned at level %d", lit, v.level);
if (v.level == level)
open++;
}
inline void Internal::analyze_reason (int lit, Clause *reason, int &open,
int &resolvent_size,
int &antecedent_size) {
assert (reason);
assert (reason != external_reason);
bump_clause (reason);
if (opts.lrat && !opts.lratexternal)
lrat_chain.push_back (reason->id);
for (const auto &other : *reason)
if (other != lit)
analyze_literal (other, open, resolvent_size, antecedent_size);
}
/*------------------------------------------------------------------------*/
// This is an idea which was implicit in MapleCOMSPS 2016 for 'limit = 1'.
// See also the paragraph on 'bumping reason side literals' in their SAT'16
// paper [LiangGaneshPoupartCzarnecki-SAT'16]. Reason side bumping was
// performed exactly when 'LRB' based decision heuristics was used, which in
// the original version was enabled after 10000 conflicts until a time limit
// of 2500 seconds was reached (half of the competition time limit). The
// Maple / Glucose / MiniSAT evolution winning the SAT race in 2019 made
// the schedule of reason side bumping deterministic, i.e., avoiding a time
// limit, by switching between 'LRB' and 'VSIDS' in an interval of initially
// 30 million propagations, which then is increased geometrically by 10%.
inline bool Internal::bump_also_reason_literal (int lit) {
assert (lit);
assert (val (lit) < 0);
Flags &f = flags (lit);
if (f.seen)
return false;
const Var &v = var (lit);
if (!v.level)
return false;
f.seen = true;
analyzed.push_back (lit);
LOG ("bumping also reason literal %d assigned at level %d", lit, v.level);
return true;
}
// We experimented with deeper reason bumping without much success though.
inline void Internal::bump_also_reason_literals (int lit, int limit) {
assert (lit);
assert (limit > 0);
const Var &v = var (lit);
assert (val (lit));
if (!v.level)
return;
Clause *reason = v.reason;
if (!reason || reason == external_reason)
return;
for (const auto &other : *reason) {
if (other == lit)
continue;
if (!bump_also_reason_literal (other))
continue;
if (limit < 2)
continue;
bump_also_reason_literals (-other, limit - 1);
}
}
inline void Internal::bump_also_all_reason_literals () {
assert (opts.bumpreason);
assert (opts.bumpreasondepth > 0);
LOG ("bumping reasons up to depth %d", opts.bumpreasondepth);
for (const auto &lit : clause)
bump_also_reason_literals (-lit, opts.bumpreasondepth + stable);
}
/*------------------------------------------------------------------------*/
void Internal::clear_unit_analyzed_literals () {
LOG ("clearing %zd unit analyzed literals", unit_analyzed.size ());
for (const auto &lit : unit_analyzed) {
Flags &f = flags (lit);
assert (f.seen);
assert (!var (lit).level);
f.seen = false;
assert (!f.keep);
assert (!f.poison);
assert (!f.removable);
}
unit_analyzed.clear ();
}
void Internal::clear_analyzed_literals () {
LOG ("clearing %zd analyzed literals", analyzed.size ());
for (const auto &lit : analyzed) {
Flags &f = flags (lit);
assert (f.seen);
f.seen = false;
assert (!f.keep);
assert (!f.poison);
assert (!f.removable);
}
analyzed.clear ();
}
void Internal::clear_analyzed_levels () {
LOG ("clearing %zd analyzed levels", levels.size ());
for (const auto &l : levels)
if (l < (int) control.size ())
control[l].reset ();
levels.clear ();
}
/*------------------------------------------------------------------------*/
// Smaller level and trail. Comparing literals on their level is necessary
// for chronological backtracking, since trail order might in this case not
// respect level order.
struct analyze_trail_negative_rank {
Internal *internal;
analyze_trail_negative_rank (Internal *s) : internal (s) {}
typedef uint64_t Type;
Type operator() (int a) {
Var &v = internal->var (a);
uint64_t res = v.level;
res <<= 32;
res |= v.trail;
return ~res;
}
};
struct analyze_trail_larger {
Internal *internal;
analyze_trail_larger (Internal *s) : internal (s) {}
bool operator() (const int &a, const int &b) const {
return analyze_trail_negative_rank (internal) (a) <
analyze_trail_negative_rank (internal) (b);
}
};
/*------------------------------------------------------------------------*/
// Generate new driving clause and compute jump level.
Clause *Internal::new_driving_clause (const int glue, int &jump) {
const size_t size = clause.size ();
Clause *res;
if (!size) {
jump = 0;
res = 0;
} else if (size == 1) {
iterating = true;
jump = 0;
res = 0;
} else {
assert (clause.size () > 1);
// We have to get the last assigned literals into the watch position.
// Sorting all literals with respect to reverse assignment order is
// overkill but seems to get slightly faster run-time. For 'minimize'
// we sort the literals too heuristically along the trail order (so in
// the opposite order) with the hope to hit the recursion limit less
// frequently. Thus sorting effort is doubled here.
//
MSORT (opts.radixsortlim, clause.begin (), clause.end (),
analyze_trail_negative_rank (this), analyze_trail_larger (this));
jump = var (clause[1]).level;
res = new_learned_redundant_clause (glue);
res->used = 1 + (glue <= opts.reducetier2glue);
}
LOG ("jump level %d", jump);
return res;
}
/*------------------------------------------------------------------------*/
// If chronological backtracking is enabled we need to find the actual
// conflict level and then potentially can also reuse the conflict clause
// as driving clause instead of deriving a redundant new driving clause
// (forcing 'forced') if the number 'count' of literals in conflict assigned
// at the conflict level is exactly one.
inline int Internal::find_conflict_level (int &forced) {
assert (conflict);
assert (opts.chrono || opts.otfs || external_prop);
int res = 0, count = 0;
forced = 0;
for (const auto &lit : *conflict) {
const int tmp = var (lit).level;
if (tmp > res) {
res = tmp;
forced = lit;
count = 1;
} else if (tmp == res) {
count++;
if (res == level && count > 1)
break;
}
}
LOG ("%d literals on actual conflict level %d", count, res);
const int size = conflict->size;
int *lits = conflict->literals;
// Move the two highest level literals to the front.
//
for (int i = 0; i < 2; i++) {
const int lit = lits[i];
int highest_position = i;
int highest_literal = lit;
int highest_level = var (highest_literal).level;
for (int j = i + 1; j < size; j++) {
const int other = lits[j];
const int tmp = var (other).level;
if (highest_level >= tmp)
continue;
highest_literal = other;
highest_position = j;
highest_level = tmp;
if (highest_level == res)
break;
}
// No unwatched higher assignment level literal.
//
if (highest_position == i)
continue;
if (highest_position > 1) {
LOG (conflict, "unwatch %d in", lit);
remove_watch (watches (lit), conflict);
}
lits[highest_position] = lit;
lits[i] = highest_literal;
if (highest_position > 1)
watch_literal (highest_literal, lits[!i], conflict);
}
// Only if the number of highest level literals in the conflict is one
// then we can reuse the conflict clause as driving clause for 'forced'.
//
if (count != 1)
forced = 0;
return res;
}
/*------------------------------------------------------------------------*/
inline int Internal::determine_actual_backtrack_level (int jump) {
int res;
assert (level > jump);
if (!opts.chrono && !external_prop) {
res = jump;
LOG ("chronological backtracking disabled using jump level %d", res);
} else if (opts.chronoalways) {
stats.chrono++;
res = level - 1;
LOG ("forced chronological backtracking to level %d", res);
} else if (jump >= level - 1) {
res = jump;
LOG ("jump level identical to chronological backtrack level %d", res);
} else if ((size_t) jump < assumptions.size ()) {
res = jump;
LOG ("using jump level %d since it is lower than assumption level %zd",
res, assumptions.size ());
} else if (level - jump > opts.chronolevelim) {
stats.chrono++;
res = level - 1;
LOG ("back-jumping over %d > %d levels prohibited"
"thus backtracking chronologically to level %d",
level - jump, opts.chronolevelim, res);
} else if (opts.chronoreusetrail) {
int best_idx = 0, best_pos = 0;
if (use_scores ()) {
for (size_t i = control[jump + 1].trail; i < trail.size (); i++) {
const int idx = abs (trail[i]);
if (best_idx && !score_smaller (this) (best_idx, idx))
continue;
best_idx = idx;
best_pos = i;
}
LOG ("best variable score %g", score (best_idx));
} else {
for (size_t i = control[jump + 1].trail; i < trail.size (); i++) {
const int idx = abs (trail[i]);
if (best_idx && bumped (best_idx) >= bumped (idx))
continue;
best_idx = idx;
best_pos = i;
}
LOG ("best variable bumped %" PRId64 "", bumped (best_idx));
}
assert (best_idx);
LOG ("best variable %d at trail position %d", best_idx, best_pos);
// Now find the frame and decision level in the control stack of that
// best variable index. Note that, as in 'reuse_trail', the frame
// 'control[i]' for decision level 'i' contains the trail before that
// decision level, i.e., the decision 'control[i].decision' sits at
// 'control[i].trail' in the trail and we thus have to check the level
// of the control frame one higher than at the result level.
//
res = jump;
while (res < level - 1 && control[res + 1].trail <= best_pos)
res++;
if (res == jump)
LOG ("default non-chronological back-jumping to level %d", res);
else {
stats.chrono++;
LOG ("chronological backtracking to level %d to reuse trail", res);
}
} else {
res = jump;
LOG ("non-chronological back-jumping to level %d", res);
}
return res;
}
/*------------------------------------------------------------------------*/
void Internal::eagerly_subsume_recently_learned_clauses (Clause *c) {
assert (opts.eagersubsume);
LOG (c, "trying eager subsumption with");
mark (c);
int64_t lim = stats.eagertried + opts.eagersubsumelim;
const auto begin = clauses.begin ();
auto it = clauses.end ();
#ifdef LOGGING
int64_t before = stats.eagersub;
#endif
while (it != begin && stats.eagertried++ <= lim) {
Clause *d = *--it;
if (c == d)
continue;
if (d->garbage)
continue;
if (!d->redundant)
continue;
int needed = c->size;
for (auto &lit : *d) {
if (marked (lit) <= 0)
continue;
if (!--needed)
break;
}
if (needed)
continue;
LOG (d, "eager subsumed");
stats.eagersub++;
stats.subsumed++;
mark_garbage (d);
}
unmark (c);
#ifdef LOGGING
uint64_t subsumed = stats.eagersub - before;
if (subsumed)
LOG ("eagerly subsumed %" PRIu64 " clauses", subsumed);
#endif
}
/*------------------------------------------------------------------------*/
Clause *Internal::on_the_fly_strengthen (Clause *new_conflict, int uip) {
assert (new_conflict);
assert (new_conflict->size > 2);
LOG (new_conflict, "applying OTFS on lit %d", uip);
auto sorted = std::vector ();
sorted.reserve (new_conflict->size);
assert (sorted.empty ());
++stats.otfs.strengthened;
int *lits = new_conflict->literals;
assert (lits[0] == uip || lits[1] == uip);
const int other_init = lits[0] ^ lits[1] ^ uip;
assert (mini_chain.empty ());
const int old_size = new_conflict->size;
int new_size = 0;
for (int i = 0; i < old_size; ++i) {
const int other = lits[i];
sorted.push_back (other);
if (var (other).level)
lits[new_size++] = other;
/*
else if (other != uip && opts.lrat && !opts.lratexternal) {
assert (val (other) < 0);
const unsigned uidx = vlit (-other);
uint64_t id = unit_clauses[uidx];
mini_chain.push_back (id);
}
*/
}
LOG (new_conflict, "removing all units ");
assert (lits[0] == uip || lits[1] == uip);
const int other = lits[0] ^ lits[1] ^ uip;
lits[0] = other;
lits[1] = lits[--new_size];
LOG (new_conflict, "putting uip at pos 1");
if (other_init != other)
remove_watch (watches (other_init), new_conflict);
remove_watch (watches (uip), new_conflict);
assert (!opts.lrat || opts.lratexternal ||
lrat_chain.back () == new_conflict->id);
if (opts.lrat && !opts.lratexternal) {
assert (!lrat_chain.empty ());
for (const auto &id : unit_chain) {
mini_chain.push_back (id);
}
const auto end = lrat_chain.rend ();
const auto begin = lrat_chain.rbegin ();
for (auto i = begin; i != end; i++) {
const auto id = *i;
mini_chain.push_back (id);
}
lrat_chain.clear (); // see if this is correct...
clear_unit_analyzed_literals ();
unit_chain.clear ();
}
assert (unit_analyzed.empty ());
// sort the clause
{
int highest_pos = 0;
int highest_level = 0;
for (int i = 1; i < new_size; i++) {
const unsigned other = lits[i];
assert (val (other) < 0);
const int level = var (other).level;
assert (level);
LOG ("checking %d", other);
if (level <= highest_level)
continue;
highest_pos = i;
highest_level = level;
}
LOG ("highest lit is %d", lits[highest_pos]);
if (highest_pos != 1)
swap (lits[1], lits[highest_pos]);
LOG ("removing %d literals", new_conflict->size - new_size);
otfs_strengthen_clause (new_conflict, uip, new_size, sorted);
assert (new_size == new_conflict->size);
}
if (other_init != other)
watch_literal (other, lits[1], new_conflict);
else {
update_watch_size (watches (other), lits[1], new_conflict);
}
watch_literal (lits[1], other, new_conflict);
LOG (new_conflict, "strengthened clause by OTFS");
sorted.clear ();
if (opts.lrat && !opts.lratexternal)
lrat_chain.push_back (new_conflict->id);
return new_conflict;
}
/*------------------------------------------------------------------------*/
inline void Internal::otfs_subsume_clause (Clause *subsuming,
Clause *subsumed) {
stats.subsumed++;
assert (subsuming->size <= subsumed->size);
LOG (subsumed, "subsumed");
if (subsumed->redundant)
stats.subred++;
else
stats.subirr++;
mark_garbage (subsumed);
if (subsumed->redundant || !subsuming->redundant)
return;
LOG ("turning redundant subsuming clause into irredundant clause");
subsuming->redundant = false;
stats.current.irredundant++;
stats.added.irredundant++;
stats.irrlits += subsuming->size;
assert (stats.current.redundant > 0);
stats.current.redundant--;
assert (stats.added.redundant > 0);
stats.added.redundant--;
// ... and keep 'stats.added.total'.
}
/*------------------------------------------------------------------------*/
// Candidate clause 'c' is strengthened by removing 'lit'.
//
void Internal::otfs_strengthen_clause (Clause *c, int lit, int new_size,
const std::vector &old) {
stats.strengthened++;
assert (c->size > 2);
(void) shrink_clause (c, new_size);
if (proof) {
if (opts.lrat && !opts.lratexternal) {
LOG (mini_chain, "otfs with chain");
proof->otfs_strengthen_clause (c, old, mini_chain);
} else
proof->otfs_strengthen_clause (c, old);
}
if (!c->redundant) {
mark_removed (lit);
}
mini_chain.clear ();
c->used = true;
LOG (c, "strengthened");
external->check_shrunken_clause (c);
}
/*------------------------------------------------------------------------*/
// This is the main conflict analysis routine. It assumes that a conflict
// was found. Then we derive the 1st UIP clause, optionally minimize it,
// add it as learned clause, and then uses the clause for conflict directed
// back-jumping and flipping the 1st UIP literal. In combination with
// chronological backtracking (see discussion above) the algorithm becomes
// slightly more involved.
void Internal::analyze () {
START (analyze);
assert (conflict);
assert (lrat_chain.empty ());
assert (unit_chain.empty ());
assert (unit_analyzed.empty ());
// First update moving averages of trail height at conflict.
//
UPDATE_AVERAGE (averages.current.trail.fast, trail.size ());
UPDATE_AVERAGE (averages.current.trail.slow, trail.size ());
/*----------------------------------------------------------------------*/
if (external_prop && !external_prop_is_lazy)
explain_external_propagations ();
if (opts.chrono || external_prop) {
int forced;
const int conflict_level = find_conflict_level (forced);
// In principle we can perform conflict analysis as in non-chronological
// backtracking except if there is only one literal with the maximum
// assignment level in the clause. Then standard conflict analysis is
// unnecessary and we can use the conflict as a driving clause. In the
// pseudo code of the SAT'18 paper on chronological backtracking this
// corresponds to the situation handled in line 4-6 in Alg. 1, except
// that the pseudo code in the paper only backtracks while we eagerly
// assign the single literal on the highest decision level.
if (forced) {
assert (forced);
assert (conflict_level > 0);
LOG ("single highest level literal %d", forced);
// The pseudo code in the SAT'18 paper actually backtracks to the
// 'second highest decision' level, while their code backtracks
// to 'conflict_level-1', which is more in the spirit of chronological
// backtracking anyhow and thus we also do the latter.
//
backtrack (conflict_level - 1);
// if we are on decision level 0 search assign will learn unit
// so we need a valid chain here (of course if we are not on decision
// level 0 this will not result in a valid chain).
// we can just use build_chain_for_units in propagate
//
build_chain_for_units (forced, conflict, 0);
LOG ("forcing %d", forced);
search_assign_driving (forced, conflict);
conflict = 0;
// lrat_chain.clear (); done in search_assign
STOP (analyze);
return;
}
// Backtracking to the conflict level is in the pseudo code in the
// SAT'18 chronological backtracking paper, but not in their actual
// implementation. In principle we do not need to backtrack here.
// However, as a side effect of backtracking to the conflict level we
// set 'level' to the conflict level which then allows us to reuse the
// old 'analyze' code as is. The alternative (which we also tried but
// then abandoned) is to use 'conflict_level' instead of 'level' in the
// analysis, which however requires to pass it to the 'analyze_reason'
// and 'analyze_literal' functions.
//
backtrack (conflict_level);
}
// Actual conflict on root level, thus formula unsatisfiable.
//
if (!level) {
learn_empty_clause ();
if (external->learner)
external->export_learned_empty_clause ();
// lrat_chain.clear (); done in learn_empty_clause
STOP (analyze);
return;
}
/*----------------------------------------------------------------------*/
// First derive the 1st UIP clause by going over literals assigned on the
// current decision level. Literals in the conflict are marked as 'seen'
// as well as all literals in reason clauses of already 'seen' literals on
// the current decision level. Thus the outer loop starts with the
// conflict clause as 'reason' and then uses the 'reason' of the next
// seen literal on the trail assigned on the current decision level.
// During this process maintain the number 'open' of seen literals on the
// current decision level with not yet processed 'reason'. As soon 'open'
// drops to one, we have found the first unique implication point. This
// is sound because the topological order in which literals are processed
// follows the assignment order and a more complex algorithm to find
// articulation points is not necessary.
//
Clause *reason = conflict;
LOG (reason, "analyzing conflict");
assert (clause.empty ());
assert (lrat_chain.empty ());
int i = trail.size (); // Start at end-of-trail.
int open = 0; // Seen but not processed on this level.
int uip = 0; // The first UIP literal.
int resolvent_size = 0; // without the uip
int antecedent_size = 1; // with the uip and without unit literals
int conflict_size =
0; // size of the conflict without the uip and without unit literals
int resolved = 0; // number of resolution (0 = clause in CNF)
const bool otfs = opts.otfs;
for (;;) {
antecedent_size = 1; // for uip
analyze_reason (uip, reason, open, resolvent_size, antecedent_size);
if (resolved == 0)
conflict_size = antecedent_size - 1;
assert (resolvent_size == open + (int) clause.size ());
if (otfs && resolved > 0 && antecedent_size > 2 &&
resolvent_size < antecedent_size) {
assert (reason != conflict);
LOG (analyzed, "found candidate for OTFS, conflict is: ");
LOG (reason, "found candidate (size %d) for OTFS, resolvent is: ",
antecedent_size);
reason = on_the_fly_strengthen (reason, uip);
assert (conflict_size >= 2);
if (resolved == 1 && resolvent_size < conflict_size) {
otfs_subsume_clause (reason, conflict);
resolved = 0;
LOG (reason, "changing conflict to");
conflict = reason;
--conflict_size;
assert (conflict_size == conflict->size);
++stats.otfs.subsumed;
++stats.subsumed;
if (open == 1) {
int forced;
const int conflict_level = find_conflict_level (forced);
int new_level =
determine_actual_backtrack_level (conflict_level - 1);
UPDATE_AVERAGE (averages.current.level, new_level);
backtrack (new_level);
LOG ("forcing %d", forced);
search_assign_driving (forced, conflict);
conflict = 0;
// Clean up.
//
clear_analyzed_literals ();
clear_analyzed_levels ();
clause.clear ();
STOP (analyze);
return;
}
}
}
++resolved;
uip = 0;
while (!uip) {
assert (i > 0);
const int lit = trail[--i];
if (!flags (lit).seen)
continue;
if (var (lit).level == level)
uip = lit;
}
if (!--open)
break;
reason = var (uip).reason;
assert (reason != external_reason);
LOG (reason, "analyzing %d reason", uip);
assert (resolvent_size);
--resolvent_size;
}
LOG ("first UIP %d", uip);
clause.push_back (-uip);
// Update glue and learned (1st UIP literals) statistics.
//
int size = (int) clause.size ();
const int glue = (int) levels.size () - 1;
LOG (clause, "1st UIP size %d and glue %d clause", size, glue);
UPDATE_AVERAGE (averages.current.glue.fast, glue);
UPDATE_AVERAGE (averages.current.glue.slow, glue);
stats.learned.literals += size;
stats.learned.clauses++;
assert (glue < size);
// up to this point lrat_chain contains the proof for current clause in
// reversed order. in minimize and shrink the clause is changed and
// therefore lrat_chain has to be extended. Unfortunately we cannot create
// the chain directly during minimazation (or shrinking) but afterwards we
// can calculate it pretty easily and even better the same algorithm works
// for both shrinking and minimization.
// Minimize the 1st UIP clause as pioneered by Niklas Soerensson in
// MiniSAT and described in our joint SAT'09 paper.
//
if (size > 1) {
if (opts.shrink)
shrink_and_minimize_clause ();
else if (opts.minimize)
minimize_clause ();
size = (int) clause.size ();
// Update decision heuristics.
//
if (opts.bump)
bump_variables ();
if (external->learner)
external->export_learned_large_clause (clause);
} else if (external->learner)
external->export_learned_unit_clause (-uip);
// Update actual size statistics.
//
stats.units += (size == 1);
stats.binaries += (size == 2);
UPDATE_AVERAGE (averages.current.size, size);
// reverse lrat_chain. We could probably work with reversed iterators
// (views) to be more efficient but we would have to distinguish in proof
//
if (opts.lrat && !opts.lratexternal) {
LOG (unit_chain, "unit chain: ");
for (auto id : unit_chain)
lrat_chain.push_back (id);
unit_chain.clear ();
reverse (lrat_chain.begin (), lrat_chain.end ());
}
// Determine back-jump level, learn driving clause, backtrack and assign
// flipped 1st UIP literal.
//
int jump;
Clause *driving_clause = new_driving_clause (glue, jump);
UPDATE_AVERAGE (averages.current.jump, jump);
int new_level = determine_actual_backtrack_level (jump);
;
UPDATE_AVERAGE (averages.current.level, new_level);
backtrack (new_level);
// It should hold that (!level <=> size == 1)
// and (!uip <=> size == 0)
// this means either we have already learned a clause => size >= 2
// in this case we will not learn empty clause or unit here
// or we haven't actually learned a clause in new_driving_clause
// then lrat_chain is still valid and we will learn a unit or empty clause
//
if (uip)
search_assign_driving (-uip, driving_clause);
else
learn_empty_clause ();
if (stable)
reluctant.tick (); // Reluctant has its own 'conflict' counter.
// Clean up.
//
clear_analyzed_literals ();
clear_unit_analyzed_literals ();
clear_analyzed_levels ();
clause.clear ();
conflict = 0;
lrat_chain.clear ();
STOP (analyze);
if (driving_clause && opts.eagersubsume)
eagerly_subsume_recently_learned_clauses (driving_clause);
}
// We wait reporting a learned unit until propagation of that unit is
// completed. Otherwise the 'i' report gives the number of remaining
// variables before propagating the unit (and hides the actual remaining
// variables after propagating it).
void Internal::iterate () {
iterating = false;
report ('i');
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/arena.cpp 0000664 0000000 0000000 00000001131 14501267155 0016246 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
Arena::Arena (Internal *i) {
memset (this, 0, sizeof *this);
internal = i;
}
Arena::~Arena () {
delete[] from.start;
delete[] to.start;
}
void Arena::prepare (size_t bytes) {
LOG ("preparing 'to' space of arena with %zd bytes", bytes);
assert (!to.start);
to.top = to.start = new char[bytes];
to.end = to.start + bytes;
}
void Arena::swap () {
delete[] from.start;
LOG ("delete 'from' space of arena with %zd bytes",
(size_t) (from.end - from.start));
from = to;
to.start = to.top = to.end = 0;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/arena.hpp 0000664 0000000 0000000 00000007075 14501267155 0016270 0 ustar 00root root 0000000 0000000 #ifndef _arena_hpp_INCLUDED
#define _arena_hpp_INCLUDED
namespace CaDiCaL {
// This memory allocation arena provides fixed size pre-allocated memory for
// the moving garbage collector 'copy_non_garbage_clauses' in 'collect.cpp'
// to hold clauses which should survive garbage collection.
// The advantage of using a pre-allocated arena is that the allocation order
// of the clauses can be adapted in such a way that clauses watched by the
// same literal are allocated consecutively. This improves locality during
// propagation and thus is more cache friendly. A similar technique is
// implemented in MiniSAT and Glucose and gives substantial speed-up in
// propagations per second even though it might even almost double peek
// memory usage. Note that in MiniSAT this arena is actually required for
// MiniSAT to be able to use 32 bit clauses references instead of 64 bit
// pointers. This would restrict the maximum number of clauses and thus is
// a restriction we do not want to use anymore.
// New learned clauses are allocated in CaDiCaL outside of this arena and
// moved to the arena during garbage collection. The additional 'to' space
// required for such a moving garbage collector is only allocated for those
// clauses surviving garbage collection, which usually needs much less
// memory than all clauses. The net effect is that in our implementation
// the moving garbage collector using this arena only needs roughly 50% more
// memory than allocating the clauses directly. Both implementations can be
// compared by varying the 'opts.arenatype' option (which also controls the
// allocation order of clauses during moving them).
// The standard sequence of using the arena is as follows:
//
// Arena arena;
// ...
// arena.prepare (bytes);
// q1 = arena.copy (p1, bytes1);
// ...
// qn = arena.copy (pn, bytesn);
// assert (bytes1 + ... + bytesn <= bytes);
// arena.swap ();
// ...
// if (!arena.contains (q)) delete q;
// ...
// arena.prepare (bytes);
// q1 = arena.copy (p1, bytes1);
// ...
// qn = arena.copy (pn, bytesn);
// assert (bytes1 + ... + bytesn <= bytes);
// arena.swap ();
// ...
//
// One has to be really careful with 'qi' references to arena memory.
struct Internal;
class Arena {
Internal *internal;
struct {
char *start, *top, *end;
} from, to;
public:
Arena (Internal *);
~Arena ();
// Prepare 'to' space to hold that amount of memory. Precondition is that
// the 'to' space is empty. The following sequence of 'copy' operations
// can use as much memory in sum as pre-allocated here.
//
void prepare (size_t bytes);
// Does the memory pointed to by 'p' belong to this arena? More precisely
// to the 'from' space, since that is the only one remaining after 'swap'.
//
bool contains (void *p) const {
char *c = (char *) p;
return from.start <= c && c < from.top;
}
// Allocate that amount of memory in 'to' space. This assumes the 'to'
// space has been prepared to hold enough memory with 'prepare'. Then
// copy the memory pointed to by 'p' of size 'bytes'. Note that it does
// not matter whether 'p' is in 'from' or allocated outside of the arena.
//
char *copy (const char *p, size_t bytes) {
char *res = to.top;
to.top += bytes;
assert (to.top <= to.end);
memcpy (res, p, bytes);
return res;
}
// Completely delete 'from' space and then replace 'from' by 'to' (by
// pointer swapping). Everything previously allocated (in 'from') and not
// explicitly copied to 'to' with 'copy' becomes invalid.
//
void swap ();
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/assume.cpp 0000664 0000000 0000000 00000025727 14501267155 0016476 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
// Failed literal handling as pioneered by MiniSAT. This first function
// adds an assumption literal onto the assumption stack.
void Internal::assume (int lit) {
Flags &f = flags (lit);
const unsigned char bit = bign (lit);
if (f.assumed & bit) {
LOG ("ignoring already assumed %d", lit);
return;
}
LOG ("assume %d", lit);
f.assumed |= bit;
assumptions.push_back (lit);
freeze (lit);
}
// for lrat we actually need to implement recursive dfs
// I don't know how to do this non-recursively...
// for non-lrat use bfs
//
void Internal::assume_analyze_literal (int lit) {
assert (lit);
Flags &f = flags (lit);
if (f.seen)
return;
f.seen = true;
analyzed.push_back (lit);
Var &v = var (lit);
assert (val (lit) < 0);
if (!v.level) {
const unsigned uidx = vlit (-lit);
uint64_t id = unit_clauses[uidx];
assert (id);
lrat_chain.push_back (id);
return;
}
if (v.reason) {
assert (v.level);
LOG (v.reason, "analyze reason");
for (const auto &other : *v.reason) {
assume_analyze_literal (other);
}
lrat_chain.push_back (v.reason->id);
return;
}
assert (assumed (-lit));
LOG ("failed assumption %d", -lit);
clause.push_back (lit);
}
void Internal::assume_analyze_reason (int lit, Clause *reason) {
assert (reason);
assert (lrat_chain.empty ());
assert (opts.lrat && !opts.lratexternal);
for (const auto &other : *reason)
if (other != lit)
assume_analyze_literal (other);
lrat_chain.push_back (reason->id);
}
// Find all failing assumptions starting from the one on the assumption
// stack with the lowest decision level. This goes back to MiniSAT and is
// called 'analyze_final' there.
void Internal::failing () {
START (analyze);
LOG ("analyzing failing assumptions");
assert (analyzed.empty ());
assert (clause.empty ());
assert (lrat_chain.empty ());
if (!unsat_constraint) {
// Search for failing assumptions in the (internal) assumption stack.
// There are in essence three cases: (1) An assumption is falsified on
// the root-level and then 'failed_unit' is set to that assumption, (2)
// two clashing assumptions are assumed and then 'failed_clashing' is
// set to the second assumed one, or otherwise (3) there is a failing
// assumption 'first_failed' with minimum (non-zero) decision level
// 'failed_level'.
int failed_unit = 0;
int failed_clashing = 0;
int first_failed = 0;
int failed_level = INT_MAX;
for (auto &lit : assumptions) {
if (val (lit) >= 0)
continue;
const Var &v = var (lit);
if (!v.level) {
failed_unit = lit;
break;
}
if (failed_clashing)
continue;
assert (v.reason != external_reason);
if (!v.reason)
failed_clashing = lit;
else if (!first_failed || v.level < failed_level) {
first_failed = lit;
failed_level = v.level;
}
}
// Get the 'failed' assumption from one of the three cases.
int failed;
if (failed_unit)
failed = failed_unit;
else if (failed_clashing)
failed = failed_clashing;
else
failed = first_failed;
assert (failed);
// In any case mark literal 'failed' as failed assumption.
{
Flags &f = flags (failed);
const unsigned bit = bign (failed);
assert (!(f.failed & bit));
f.failed |= bit;
}
// First case (1).
if (failed_unit) {
assert (failed == failed_unit);
LOG ("root-level falsified assumption %d", failed);
goto DONE;
}
// Second case (2).
if (failed_clashing) {
assert (failed == failed_clashing);
LOG ("clashing assumptions %d and %d", failed, -failed);
Flags &f = flags (-failed);
const unsigned bit = bign (-failed);
assert (!(f.failed & bit));
f.failed |= bit;
goto DONE;
}
// Fall through to third case (3).
LOG ("starting with assumption %d falsified on minimum decision level "
"%d",
first_failed, failed_level);
assert (first_failed);
assert (failed_level > 0);
// The 'analyzed' stack serves as working stack for a BFS through the
// implication graph until decisions, which are all assumptions, or
// units are reached. This is simpler than corresponding code in
// 'analyze'.
{
LOG ("failed assumption %d", first_failed);
Flags &f = flags (first_failed);
assert (!f.seen);
f.seen = true;
assert (f.failed & bign (first_failed));
analyzed.push_back (-first_failed);
clause.push_back (-first_failed);
}
} else { // unsat_constraint
// The assumptions necessary to fail each literal in the constraint are
// collected.
for (auto lit : constraint) {
lit *= -1;
assert (lit != INT_MIN);
flags (lit).seen = true;
analyzed.push_back (lit);
}
}
{
// used for unsat_constraint lrat
vector> constraint_chains;
vector> constraint_clauses;
vector sum_constraints;
// no lrat do bfs as it was before
if (!opts.lrat || opts.lratexternal) {
size_t next = 0;
while (next < analyzed.size ()) {
const int lit = analyzed[next++];
assert (val (lit) > 0);
Var &v = var (lit);
if (!v.level)
continue;
if (v.reason) {
assert (v.level);
LOG (v.reason, "analyze reason");
for (const auto &other : *v.reason) {
Flags &f = flags (other);
if (f.seen)
continue;
f.seen = true;
assert (val (other) < 0);
analyzed.push_back (-other);
}
} else {
assert (assumed (lit));
LOG ("failed assumption %d", lit);
clause.push_back (-lit);
Flags &f = flags (lit);
const unsigned bit = bign (lit);
assert (!(f.failed & bit));
f.failed |= bit;
}
}
clear_analyzed_literals ();
} else if (!unsat_constraint) { // lrat for case (3)
assert (clause.size () == 1);
const int lit = clause[0];
Var &v = var (lit);
assert (v.reason);
assume_analyze_reason (lit, v.reason);
for (auto &lit : clause) {
Flags &f = flags (lit);
const unsigned bit = bign (-lit);
if (!(f.failed & bit))
f.failed |= bit;
}
clear_analyzed_literals ();
} else { // lrat for unsat_constraint
assert (clause.empty ());
clear_analyzed_literals ();
/*
const size_t size = 2 * (1 + (size_t) max_var);
constraint_chains.resize (size);
constraint_clauses.resize (size);
for (size_t i = 0; i > size; i++) {
vector empty;
vector empty2;
constraint_chains[i] = empty;
constraint_clauses[i] = empty2;
}
*/
for (auto lit : constraint) {
// make sure nothing gets marked failed twice
// also might shortcut the case where
// lrat_chain is empty because clause is tautological
assert (lit != INT_MIN);
/*
for (auto ign : clause) {
Flags &f = flags (ign);
if (f.seen)
continue;
f.seen = true;
analyzed.push_back (ign);
}
*/
assume_analyze_literal (lit);
vector empty;
vector empty2;
constraint_chains.push_back (empty);
constraint_clauses.push_back (empty2);
for (auto ign : clause) {
constraint_clauses.back ().push_back (ign);
Flags &f = flags (ign);
const unsigned bit = bign (-ign);
if (!(f.failed & bit)) {
sum_constraints.push_back (ign);
assert (!(f.failed & bit));
f.failed |= bit;
}
}
clause.clear ();
clear_analyzed_literals ();
for (auto p : lrat_chain) {
constraint_chains.back ().push_back (p);
}
lrat_chain.clear ();
}
for (auto &lit : sum_constraints)
clause.push_back (lit);
}
clear_analyzed_literals ();
// TODO: We can not do clause minimization here, right?
VERBOSE (1, "found %zd failed assumptions %.0f%%", clause.size (),
percent (clause.size (), assumptions.size ()));
// We do not actually need to learn this clause, since the conflict is
// forced already by some other clauses. There is also no bumping
// of variables nor clauses necessary. But we still want to check
// correctness of the claim that the determined subset of failing
// assumptions are a high-level core or equivalently their negations
// form a unit-implied clause.
//
if (!unsat_constraint) {
external->check_learned_clause ();
if (proof) {
if (opts.lrat && !opts.lratexternal) {
LOG (lrat_chain, "assume proof chain without constraint");
proof->add_derived_clause (++clause_id, clause, lrat_chain);
} else
proof->add_derived_clause (++clause_id, clause);
proof->delete_clause (clause_id, clause);
}
} else {
assert (!opts.lrat || opts.lratexternal ||
(constraint.size () == constraint_clauses.size () &&
constraint.size () == constraint_chains.size ()));
for (auto p = constraint.rbegin (); p != constraint.rend (); p++) {
const auto &lit = *p;
if (opts.lrat && !opts.lratexternal) {
clause.clear ();
for (auto &ign : constraint_clauses.back ())
clause.push_back (ign);
constraint_clauses.pop_back ();
}
clause.push_back (-lit);
external->check_learned_clause ();
if (proof) {
if (opts.lrat && !opts.lratexternal) {
for (auto p : constraint_chains.back ()) {
lrat_chain.push_back (p);
}
constraint_chains.pop_back ();
LOG (lrat_chain, "assume proof chain with constraints");
proof->add_derived_clause (++clause_id, clause, lrat_chain);
lrat_chain.clear ();
proof->delete_clause (clause_id, clause);
} else {
proof->add_derived_clause (++clause_id, clause);
proof->delete_clause (clause_id, clause);
}
}
clause.pop_back ();
}
}
lrat_chain.clear ();
clause.clear ();
}
DONE:
STOP (analyze);
}
bool Internal::failed (int lit) {
if (!marked_failed) {
failing ();
marked_failed = true;
}
Flags &f = flags (lit);
const unsigned bit = bign (lit);
return (f.failed & bit) != 0;
}
// Add the start of each incremental phase (leaving the state
// 'UNSATISFIABLE' actually) we reset all assumptions.
void Internal::reset_assumptions () {
for (const auto &lit : assumptions) {
Flags &f = flags (lit);
const unsigned char bit = bign (lit);
f.assumed &= ~bit;
f.failed &= ~bit;
melt (lit);
}
LOG ("cleared %zd assumptions", assumptions.size ());
assumptions.clear ();
marked_failed = true;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/averages.cpp 0000664 0000000 0000000 00000001450 14501267155 0016761 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
void Internal::init_averages () {
LOG ("initializing averages");
INIT_EMA (averages.current.jump, opts.emajump);
INIT_EMA (averages.current.level, opts.emalevel);
INIT_EMA (averages.current.size, opts.emasize);
INIT_EMA (averages.current.glue.fast, opts.emagluefast);
INIT_EMA (averages.current.glue.slow, opts.emaglueslow);
INIT_EMA (averages.current.trail.fast, opts.ematrailfast);
INIT_EMA (averages.current.trail.slow, opts.ematrailslow);
assert (!averages.swapped);
}
void Internal::swap_averages () {
LOG ("saving current averages");
swap (averages.current, averages.saved);
if (!averages.swapped)
init_averages ();
else
LOG ("swapping in previously saved averages");
averages.swapped++;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/averages.hpp 0000664 0000000 0000000 00000001413 14501267155 0016765 0 ustar 00root root 0000000 0000000 #ifndef _averages_hpp_INCLUDED
#define _averages_hpp_INCLUDED
#include "ema.hpp" // alphabetically after 'averages.hpp'
namespace CaDiCaL {
struct Averages {
int64_t swapped;
struct {
struct {
EMA fast; // average fast (small window) moving glucose level
EMA slow; // average slow (large window) moving glucose level
} glue;
struct {
EMA fast; // average fast (small window) moving trail level
EMA slow; // average slow (large window) moving trail level
} trail;
EMA size; // average learned clause size
EMA jump; // average (potential non-chronological) back-jump level
EMA level; // average back track level after conflict
} current, saved;
Averages () : swapped (0) {}
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/backtrack.cpp 0000664 0000000 0000000 00000011402 14501267155 0017107 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
// The global assignment stack can only be (partially) reset through
// 'backtrack' which is the only function using 'unassign' (inlined and thus
// local to this file). It turns out that 'unassign' does not need a
// specialization for 'probe' nor 'vivify' and thus it is shared.
inline void Internal::unassign (int lit) {
assert (val (lit) > 0);
const int idx = vidx (lit);
vals[idx] = 0;
vals[-idx] = 0;
LOG ("unassign %d @ %d", lit, var (idx).level);
// In the standard EVSIDS variable decision heuristic of MiniSAT, we need
// to push variables which become unassigned back to the heap.
//
if (!scores.contains (idx))
scores.push_back (idx);
// For VMTF we need to update the 'queue.unassigned' pointer in case this
// variable sits after the variable to which 'queue.unassigned' currently
// points. See our SAT'15 paper for more details on this aspect.
//
if (queue.bumped < btab[idx])
update_queue_unassigned (idx);
}
/*------------------------------------------------------------------------*/
// Update the current target maximum assignment and also the very best
// assignment. Whether a trail produces a conflict is determined during
// propagation. Thus that all functions in the 'search' loop after
// propagation can assume that 'no_conflict_until' is valid. If a conflict
// is found then the trail before the last decision is used (see the end of
// 'propagate'). During backtracking we can then save this largest
// propagation conflict free assignment. It is saved as both 'target'
// assignment for picking decisions in 'stable' mode and if it is the
// largest ever such assignment also as 'best' assignment. This 'best'
// assignment can then be used in future stable decisions after the next
// 'rephase_best' overwrites saved phases with it.
void Internal::update_target_and_best () {
bool reset = (rephased && stats.conflicts > last.rephase.conflicts);
if (reset) {
target_assigned = 0;
if (rephased == 'B')
best_assigned = 0; // update it again
}
if (no_conflict_until > target_assigned) {
copy_phases (phases.target);
target_assigned = no_conflict_until;
LOG ("new target trail level %zu", target_assigned);
}
if (no_conflict_until > best_assigned) {
copy_phases (phases.best);
best_assigned = no_conflict_until;
LOG ("new best trail level %zu", best_assigned);
}
if (reset) {
report (rephased);
rephased = 0;
}
}
/*------------------------------------------------------------------------*/
void Internal::backtrack (int new_level) {
assert (new_level <= level);
if (new_level == level)
return;
stats.backtracks++;
update_target_and_best ();
const size_t assigned = control[new_level + 1].trail;
LOG ("backtracking to decision level %d with decision %d and trail %zd",
new_level, control[new_level].decision, assigned);
const size_t end_of_trail = trail.size ();
size_t i = assigned, j = i;
#ifdef LOGGING
int unassigned = 0;
#endif
int reassigned = 0;
notify_backtrack (new_level);
if (external_prop && !external_prop_is_lazy && notified > assigned) {
LOG ("external propagator is notified about some unassignments (trail: "
"%zd, notified: %zd).",
trail.size (), notified);
notified = assigned;
}
while (i < end_of_trail) {
int lit = trail[i++];
Var &v = var (lit);
if (v.level > new_level) {
unassign (lit);
#ifdef LOGGING
unassigned++;
#endif
} else {
// This is the essence of the SAT'18 paper on chronological
// backtracking. It is possible to just keep out-of-order assigned
// literals on the trail without breaking the solver (after some
// modifications to 'analyze' - see 'opts.chrono' guarded code there).
assert (opts.chrono || external_prop || did_external_prop);
#ifdef LOGGING
if (!v.level)
LOG ("reassign %d @ 0 unit clause %d", lit, lit);
else
LOG (v.reason, "reassign %d @ %d", lit, v.level);
#endif
trail[j] = lit;
v.trail = j++;
#ifdef LOGGING
reassigned++;
#endif
}
}
trail.resize (j);
LOG ("unassigned %d literals %.0f%%", unassigned,
percent (unassigned, unassigned + reassigned));
LOG ("reassigned %d literals %.0f%%", reassigned,
percent (reassigned, unassigned + reassigned));
if (propagated > assigned)
propagated = assigned;
if (propagated2 > assigned)
propagated2 = assigned;
if (no_conflict_until > assigned)
no_conflict_until = assigned;
propergated = 0; // Always go back to root-level.
assert (notified <= assigned + reassigned);
if (reassigned) {
notify_assignments ();
}
control.resize (new_level + 1);
level = new_level;
if (!level)
did_external_prop = false;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/backward.cpp 0000664 0000000 0000000 00000015241 14501267155 0016745 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// Provide eager backward subsumption for resolved clauses.
// The eliminator maintains a queue of clauses that are new and have to be
// checked to subsume or strengthen other (longer or same size) clauses.
void Eliminator::enqueue (Clause *c) {
if (!internal->opts.elimbackward)
return;
if (c->enqueued)
return;
LOG (c, "backward enqueue");
backward.push (c);
c->enqueued = true;
}
Clause *Eliminator::dequeue () {
if (backward.empty ())
return 0;
Clause *res = backward.front ();
backward.pop ();
assert (res->enqueued);
res->enqueued = false;
LOG (res, "backward dequeue");
return res;
}
Eliminator::~Eliminator () {
while (dequeue ())
;
}
/*------------------------------------------------------------------------*/
void Internal::elim_backward_clause (Eliminator &eliminator, Clause *c) {
assert (opts.elimbackward);
assert (!c->redundant);
if (c->garbage)
return;
LOG (c, "attempting backward subsumption and strengthening with");
size_t len = UINT_MAX;
unsigned size = 0;
int best = 0;
bool satisfied = false;
assert (mini_chain.empty ());
for (const auto &lit : *c) {
const signed char tmp = val (lit);
if (tmp > 0) {
satisfied = true;
break;
}
if (tmp < 0)
continue;
size_t l = occs (lit).size ();
LOG ("literal %d occurs %zd times", lit, l);
if (l < len)
best = lit, len = l;
mark (lit);
size++;
}
if (satisfied) {
LOG ("clause actually already satisfied");
elim_update_removed_clause (eliminator, c);
mark_garbage (c);
} else if (len > (size_t) opts.elimocclim) {
LOG ("skipping backward subsumption due to too many occurrences");
} else {
assert (len);
LOG ("literal %d has smallest number of occurrences %zd", best, len);
LOG ("marked %d literals in clause of size %d", size, c->size);
for (auto &d : occs (best)) {
if (d == c)
continue;
if (d->garbage)
continue;
if ((unsigned) d->size < size)
continue;
int negated = 0;
unsigned found = 0;
for (const auto &lit : *d) {
signed char tmp = val (lit);
if (tmp > 0) {
satisfied = true;
break;
}
if (tmp < 0)
continue;
tmp = marked (lit);
if (!tmp)
continue;
if (tmp < 0) {
if (negated) {
size = UINT_MAX;
break;
} else
negated = lit;
}
if (++found == size)
break;
}
if (satisfied) {
LOG (d, "found satisfied clause");
elim_update_removed_clause (eliminator, d);
mark_garbage (d);
} else if (found == size) {
if (!negated) {
LOG (d, "found subsumed clause");
elim_update_removed_clause (eliminator, d);
mark_garbage (d);
stats.subsumed++;
stats.elimbwsub++;
} else {
int unit = 0;
assert (minimize_chain.empty ());
assert (analyzed.empty ());
assert (lrat_chain.empty ());
for (const auto &lit : *d) { // find out if we get
const signed char tmp = val (lit); // a new unit or just
if (tmp < 0) { // strengthen c
if (!opts.lrat || opts.lratexternal)
continue;
Flags &f = flags (lit);
assert (!f.seen);
if (f.seen)
continue;
f.seen = true;
analyzed.push_back (lit);
continue;
}
if (tmp > 0) {
satisfied = true;
break;
}
if (lit == negated)
continue;
if (unit) {
unit = INT_MIN;
break;
} else
unit = lit;
}
if (opts.lrat && !opts.lratexternal && !satisfied) {
// if we found a unit we need to add all unit ids from
// {c\d}U{d\c} otherwise just the unit ids from {c\d}
for (const auto &lit : *c) {
const signed char tmp = val (lit);
assert (tmp <= 0);
if (tmp >= 0)
continue;
Flags &f = flags (lit);
if (f.seen && unit && unit == INT_MIN) {
f.seen = false;
continue;
} else if (!f.seen) {
f.seen = true;
analyzed.push_back (lit);
}
}
if (unit == INT_MIN) { // we do not need units from {d\c}
for (const auto &lit : *d) {
flags (lit).seen = false;
}
}
for (const auto &lit : analyzed) {
Flags &f = flags (lit);
if (!f.seen) {
f.seen = true;
continue;
}
const unsigned uidx = vlit (-lit);
uint64_t id = unit_clauses[uidx];
assert (id);
lrat_chain.push_back (id);
}
clear_analyzed_literals ();
lrat_chain.push_back (d->id);
lrat_chain.push_back (c->id);
}
if (satisfied) {
assert (lrat_chain.empty ());
mark_garbage (d);
elim_update_removed_clause (eliminator, d);
} else if (unit && unit != INT_MIN) {
assert (unit);
LOG (d, "unit %d through hyper unary resolution with", unit);
assign_unit (unit);
elim_propagate (eliminator, unit);
lrat_chain.clear ();
break;
} else if (occs (negated).size () <= (size_t) opts.elimocclim) {
strengthen_clause (d, negated);
remove_occs (occs (negated), d);
elim_update_removed_lit (eliminator, negated);
stats.elimbwstr++;
assert (negated != best);
eliminator.enqueue (d);
}
lrat_chain.clear ();
}
}
}
}
mini_chain.clear ();
unmark (c);
}
/*------------------------------------------------------------------------*/
void Internal::elim_backward_clauses (Eliminator &eliminator) {
if (!opts.elimbackward) {
assert (eliminator.backward.empty ());
return;
}
START (backward);
LOG ("attempting backward subsumption and strengthening with %zd clauses",
eliminator.backward.size ());
Clause *c;
while (!unsat && (c = eliminator.dequeue ()))
elim_backward_clause (eliminator, c);
STOP (backward);
}
/*------------------------------------------------------------------------*/
} // namespace CaDiCaL
cadical-rel-1.7.4/src/bins.cpp 0000664 0000000 0000000 00000000741 14501267155 0016121 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// Binary implication graph lists.
void Internal::init_bins () {
assert (big.empty ());
if (big.size () < 2 * vsize)
big.resize (2 * vsize, Bins ());
LOG ("initialized binary implication graph");
}
void Internal::reset_bins () {
assert (!big.empty ());
erase_vector (big);
LOG ("reset binary implication graph");
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/bins.hpp 0000664 0000000 0000000 00000000561 14501267155 0016126 0 ustar 00root root 0000000 0000000 #ifndef _bins_hpp_INCLUDED
#define _bins_hpp_INCLUDED
#include "util.hpp" // Alphabetically after 'bins'.
namespace CaDiCaL {
using namespace std;
struct Bin {
int lit;
uint64_t id;
};
typedef vector Bins;
inline void shrink_bins (Bins &bs) { shrink_vector (bs); }
inline void erase_bins (Bins &bs) { erase_vector (bs); }
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/block.cpp 0000664 0000000 0000000 00000054341 14501267155 0016265 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// This implements an inprocessing version of blocked clause elimination and
// is assumed to be triggered just before bounded variable elimination. It
// has a separate 'block' flag while variable elimination uses 'elim'.
// Thus it only tries to block clauses on a literal which was removed in an
// irredundant clause in negated form before and has not been tried to use
// as blocking literal since then.
/*------------------------------------------------------------------------*/
inline bool block_more_occs_size::operator() (unsigned a, unsigned b) {
size_t s = internal->noccs (-internal->u2i (a));
size_t t = internal->noccs (-internal->u2i (b));
if (s > t)
return true;
if (s < t)
return false;
s = internal->noccs (internal->u2i (a));
t = internal->noccs (internal->u2i (b));
if (s > t)
return true;
if (s < t)
return false;
return a > b;
}
/*------------------------------------------------------------------------*/
// Determine whether 'c' is blocked on 'lit', by first marking all its
// literals and then checking all resolvents with negative clauses (with
// '-lit') are tautological. We use a move-to-front scheme for both the
// occurrence list of negative clauses (with '-lit') and then for literals
// within each such clause. The clause move-to-front scheme has the goal to
// find non-tautological clauses faster in the future, while the literal
// move-to-front scheme has the goal to faster find the matching literal,
// which makes the resolvent tautological (again in the future).
bool Internal::is_blocked_clause (Clause *c, int lit) {
LOG (c, "trying to block on %d", lit);
assert (c->size >= opts.blockminclslim);
assert (c->size <= opts.blockmaxclslim);
assert (active (lit));
assert (!val (lit));
assert (!c->garbage);
assert (!c->redundant);
assert (!level);
mark (c); // First mark all literals in 'c'.
Occs &os = occs (-lit);
LOG ("resolving against at most %zd clauses with %d", os.size (), -lit);
bool res = true; // Result is true if all resolvents tautological.
// Can not use 'auto' here since we update 'os' during traversal.
//
const auto end_of_os = os.end ();
auto i = os.begin ();
Clause *prev_d = 0; // Previous non-tautological clause.
for (; i != end_of_os; i++) {
// Move the first clause with non-tautological resolvent to the front of
// the occurrence list to improve finding it faster later.
//
Clause *d = *i;
assert (!d->garbage);
assert (!d->redundant);
assert (d->size <= opts.blockmaxclslim);
*i = prev_d; // Move previous non-tautological clause
prev_d = d; // backwards but remember clause at this position.
LOG (d, "resolving on %d against", lit);
stats.blockres++;
int prev_other = 0; // Previous non-tautological literal.
// No 'auto' since we update literals of 'd' during traversal.
//
const const_literal_iterator end_of_d = d->end ();
literal_iterator l;
for (l = d->begin (); l != end_of_d; l++) {
// Same move-to-front mechanism for literals within a clause. It
// moves the first negatively marked literal to the front to find it
// faster in the future.
//
const int other = *l;
*l = prev_other;
prev_other = other;
if (other == -lit)
continue;
assert (other != lit);
assert (active (other));
assert (!val (other));
if (marked (other) < 0) {
LOG ("found tautological literal %d", other);
d->literals[0] = other; // Move to front of 'd'.
break;
}
}
if (l == end_of_d) {
LOG ("no tautological literal found");
//
// Since we did not find a tautological literal we restore the old
// order of literals in the clause.
//
const const_literal_iterator begin_of_d = d->begin ();
while (l-- != begin_of_d) {
const int other = *l;
*l = prev_other;
prev_other = other;
}
res = false; // Now 'd' is a witness that 'c' is not blocked.
os[0] = d; // Move it to the front of the occurrence list.
break;
}
}
unmark (c); // ... all literals of the candidate clause.
// If all resolvents are tautological and thus the clause is blocked we
// restore the old order of clauses in the occurrence list of '-lit'.
//
if (res) {
assert (i == end_of_os);
const auto boc = os.begin ();
while (i != boc) {
Clause *d = *--i;
*i = prev_d;
prev_d = d;
}
}
return res;
}
/*------------------------------------------------------------------------*/
void Internal::block_schedule (Blocker &blocker) {
// Set skip flags for all literals in too large clauses.
//
for (const auto &c : clauses) {
if (c->garbage)
continue;
if (c->redundant)
continue;
if (c->size <= opts.blockmaxclslim)
continue;
for (const auto &lit : *c)
mark_skip (-lit);
}
// Connect all literal occurrences in irredundant clauses.
//
for (const auto &c : clauses) {
if (c->garbage)
continue;
if (c->redundant)
continue;
for (const auto &lit : *c) {
assert (active (lit));
assert (!val (lit));
occs (lit).push_back (c);
}
}
// We establish the invariant that 'noccs' gives the number of actual
// occurrences of 'lit' in non-garbage clauses, while 'occs' might still
// refer to garbage clauses, thus 'noccs (lit) <= occs (lit).size ()'. It
// is expensive to remove references to garbage clauses from 'occs' during
// blocked clause elimination, but decrementing 'noccs' is cheap.
for (auto lit : lits) {
if (!active (lit))
continue;
assert (!val (lit));
Occs &os = occs (lit);
noccs (lit) = os.size ();
}
// Now we fill the schedule (priority queue) of candidate literals to be
// tried as blocking literals. It is probably slightly faster to do this
// in one go after all occurrences have been determined, instead of
// filling the priority queue during pushing occurrences. Filling the
// schedule can not be fused with the previous loop (easily) since we
// first have to initialize 'noccs' for both 'lit' and '-lit'.
#ifndef QUIET
int skipped = 0;
#endif
for (auto idx : vars) {
if (!active (idx))
continue;
if (frozen (idx)) {
#ifndef QUIET
skipped += 2;
#endif
continue;
}
assert (!val (idx));
for (int sign = -1; sign <= 1; sign += 2) {
const int lit = sign * idx;
if (marked_skip (lit)) {
#ifndef QUIET
skipped++;
#endif
continue;
}
if (!marked_block (lit))
continue;
unmark_block (lit);
LOG ("scheduling %d with %" PRId64 " positive and %" PRId64
" negative occurrences",
lit, noccs (lit), noccs (-lit));
blocker.schedule.push_back (vlit (lit));
}
}
PHASE ("block", stats.blockings,
"scheduled %zd candidate literals %.2f%% (%d skipped %.2f%%)",
blocker.schedule.size (),
percent (blocker.schedule.size (), 2.0 * active ()), skipped,
percent (skipped, 2.0 * active ()));
}
/*------------------------------------------------------------------------*/
// A literal is pure if it only occurs positive. Then all clauses in which
// it occurs are blocked on it. This special case can be implemented faster
// than trying to block literals with at least one negative occurrence and
// is thus handled separately. It also allows to avoid pushing blocked
// clauses onto the extension stack.
void Internal::block_pure_literal (Blocker &blocker, int lit) {
if (frozen (lit))
return;
assert (active (lit));
Occs &pos = occs (lit);
Occs &nos = occs (-lit);
assert (!noccs (-lit));
#ifndef NDEBUG
for (const auto &c : nos)
assert (c->garbage);
#endif
stats.blockpurelits++;
LOG ("found pure literal %d", lit);
#ifdef LOGGING
int64_t pured = 0;
#endif
for (const auto &c : pos) {
if (c->garbage)
continue;
assert (!c->redundant);
LOG (c, "pure literal %d in", lit);
blocker.reschedule.push_back (c);
external->push_clause_on_extension_stack (c, lit);
stats.blockpured++;
mark_garbage (c);
#ifdef LOGGING
pured++;
#endif
}
erase_vector (pos);
erase_vector (nos);
mark_pure (lit);
stats.blockpured++;
LOG ("blocking %" PRId64 " clauses on pure literal %d", pured, lit);
}
/*------------------------------------------------------------------------*/
// If there is only one negative clause with '-lit' it is faster to mark it
// instead of marking all the positive clauses with 'lit' one after the
// other and then resolving against the negative clause.
void Internal::block_literal_with_one_negative_occ (Blocker &blocker,
int lit) {
assert (active (lit));
assert (!frozen (lit));
assert (noccs (lit) > 0);
assert (noccs (-lit) == 1);
Occs &nos = occs (-lit);
assert (nos.size () >= 1);
Clause *d = 0;
for (const auto &c : nos) {
if (c->garbage)
continue;
assert (!d);
d = c;
#ifndef NDEBUG
break;
#endif
}
assert (d);
nos.resize (1);
nos[0] = d;
if (d && d->size > opts.blockmaxclslim) {
LOG (d, "skipped common antecedent");
return;
}
assert (!d->garbage);
assert (!d->redundant);
assert (d->size <= opts.blockmaxclslim);
LOG (d, "common %d antecedent", lit);
mark (d);
int64_t blocked = 0;
#ifdef LOGGING
int64_t skipped = 0;
#endif
Occs &pos = occs (lit);
// Again no 'auto' since 'pos' is update during traversal.
//
const auto eop = pos.end ();
auto j = pos.begin (), i = j;
for (; i != eop; i++) {
Clause *c = *j++ = *i;
if (c->garbage) {
j--;
continue;
}
if (c->size > opts.blockmaxclslim) {
#ifdef LOGGING
skipped++;
#endif
continue;
}
if (c->size < opts.blockminclslim) {
#ifdef LOGGING
skipped++;
#endif
continue;
}
LOG (c, "trying to block on %d", lit);
// We use the same literal move-to-front strategy as in
// 'is_blocked_clause'. See there for more explanations.
int prev_other = 0; // Previous non-tautological literal.
// No 'auto' since literals of 'c' are updated during traversal.
//
const const_literal_iterator end_of_c = c->end ();
literal_iterator l;
for (l = c->begin (); l != end_of_c; l++) {
const int other = *l;
*l = prev_other;
prev_other = other;
if (other == lit)
continue;
assert (other != -lit);
assert (active (other));
assert (!val (other));
if (marked (other) < 0) {
LOG ("found tautological literal %d", other);
c->literals[0] = other; // Move to front of 'c'.
break;
}
}
if (l == end_of_c) {
LOG ("no tautological literal found");
// Restore old literal order in the clause because.
const const_literal_iterator begin_of_c = c->begin ();
while (l-- != begin_of_c) {
const int other = *l;
*l = prev_other;
prev_other = other;
}
continue; // ... with next candidate 'c' in 'pos'.
}
blocked++;
LOG (c, "blocked");
external->push_clause_on_extension_stack (c, lit);
blocker.reschedule.push_back (c);
mark_garbage (c);
j--;
}
if (j == pos.begin ())
erase_vector (pos);
else
pos.resize (j - pos.begin ());
stats.blocked += blocked;
LOG ("blocked %" PRId64 " clauses on %d (skipped %" PRId64 ")", blocked,
lit, skipped);
unmark (d);
}
/*------------------------------------------------------------------------*/
// Determine the set of candidate clauses with 'lit', which are checked to
// be blocked by 'lit'. Filter out too large and small clauses and which do
// not have any negated other literal in any of the clauses with '-lit'.
size_t Internal::block_candidates (Blocker &blocker, int lit) {
assert (blocker.candidates.empty ());
Occs &pos = occs (lit); // Positive occurrences of 'lit'.
Occs &nos = occs (-lit);
assert ((size_t) noccs (lit) <= pos.size ());
assert ((size_t) noccs (-lit) == nos.size ()); // Already flushed.
// Mark all literals in clauses with '-lit'. Note that 'mark2' uses
// separate bits for 'lit' and '-lit'.
//
for (const auto &c : nos)
mark2 (c);
const auto eop = pos.end ();
auto j = pos.begin (), i = j;
for (; i != eop; i++) {
Clause *c = *j++ = *i;
if (c->garbage) {
j--;
continue;
}
assert (!c->redundant);
if (c->size > opts.blockmaxclslim)
continue;
if (c->size < opts.blockminclslim)
continue;
const const_literal_iterator eoc = c->end ();
const_literal_iterator l;
for (l = c->begin (); l != eoc; l++) {
const int other = *l;
if (other == lit)
continue;
assert (other != -lit);
assert (active (other));
assert (!val (other));
if (marked2 (-other))
break;
}
if (l != eoc)
blocker.candidates.push_back (c);
}
if (j == pos.begin ())
erase_vector (pos);
else
pos.resize (j - pos.begin ());
assert (pos.size () == (size_t) noccs (lit)); // Now also flushed.
for (const auto &c : nos)
unmark (c);
return blocker.candidates.size ();
}
/*------------------------------------------------------------------------*/
// Try to find a clause with '-lit' which does not have any literal in
// clauses with 'lit'. If such a clause exists no candidate clause can be
// blocked on 'lit' since all candidates would produce a non-tautological
// resolvent with that clause.
Clause *Internal::block_impossible (Blocker &blocker, int lit) {
assert (noccs (-lit) > 1);
assert (blocker.candidates.size () > 1);
for (const auto &c : blocker.candidates)
mark2 (c);
Occs &nos = occs (-lit);
Clause *res = 0;
for (const auto &c : nos) {
assert (!c->garbage);
assert (!c->redundant);
assert (c->size <= opts.blockmaxclslim);
const const_literal_iterator eoc = c->end ();
const_literal_iterator l;
for (l = c->begin (); l != eoc; l++) {
const int other = *l;
if (other == -lit)
continue;
assert (other != lit);
assert (active (other));
assert (!val (other));
if (marked2 (-other))
break;
}
if (l == eoc)
res = c;
}
for (const auto &c : blocker.candidates)
unmark (c);
if (res) {
LOG (res, "common non-tautological resolvent producing");
blocker.candidates.clear ();
}
return res;
}
/*------------------------------------------------------------------------*/
// In the general case we have at least two negative occurrences.
void Internal::block_literal_with_at_least_two_negative_occs (
Blocker &blocker, int lit) {
assert (active (lit));
assert (!frozen (lit));
assert (noccs (lit) > 0);
assert (noccs (-lit) > 1);
Occs &nos = occs (-lit);
assert ((size_t) noccs (-lit) <= nos.size ());
int max_size = 0;
// Flush all garbage clauses in occurrence list 'nos' of '-lit' and
// determine the maximum size of negative clauses (with '-lit').
//
const auto eon = nos.end ();
auto j = nos.begin (), i = j;
for (; i != eon; i++) {
Clause *c = *j++ = *i;
if (c->garbage)
j--;
else if (c->size > max_size)
max_size = c->size;
}
if (j == nos.begin ())
erase_vector (nos);
else
nos.resize (j - nos.begin ());
assert (nos.size () == (size_t) noccs (-lit));
assert (nos.size () > 1);
// If the maximum size of a negative clause (with '-lit') exceeds the
// maximum clause size limit ignore this candidate literal.
//
if (max_size > opts.blockmaxclslim) {
LOG ("maximum size %d of clauses with %d exceeds clause size limit %d",
max_size, -lit, opts.blockmaxclslim);
return;
}
LOG ("maximum size %d of clauses with %d", max_size, -lit);
// We filter candidate clauses with positive occurrence of 'lit' in
// 'blocker.candidates' and return if no candidate clause remains.
// Candidates should be small enough and should have at least one literal
// which occurs negated in one of the clauses with '-lit'.
//
size_t candidates = block_candidates (blocker, lit);
if (!candidates) {
LOG ("no candidate clauses found");
return;
}
LOG ("found %zd candidate clauses", candidates);
// We further search for a clause with '-lit' that has no literal
// negated in any of the candidate clauses (except 'lit'). If such a
// clause exists, we know that none of the candidates is blocked.
//
if (candidates > 1 && block_impossible (blocker, lit)) {
LOG ("impossible to block any candidate clause on %d", lit);
assert (blocker.candidates.empty ());
return;
}
LOG ("trying to block %zd clauses out of %" PRId64 " with literal %d",
candidates, noccs (lit), lit);
int64_t blocked = 0;
// Go over all remaining candidates and try to block them on 'lit'.
//
for (const auto &c : blocker.candidates) {
assert (!c->garbage);
assert (!c->redundant);
if (!is_blocked_clause (c, lit))
continue;
blocked++;
LOG (c, "blocked");
external->push_clause_on_extension_stack (c, lit);
blocker.reschedule.push_back (c);
mark_garbage (c);
}
LOG ("blocked %" PRId64
" clauses on %d out of %zd candidates in %zd occurrences",
blocked, lit, blocker.candidates.size (), occs (lit).size ());
blocker.candidates.clear ();
stats.blocked += blocked;
if (blocked)
flush_occs (lit);
}
/*------------------------------------------------------------------------*/
// Reschedule literals in a clause (except 'lit') which was blocked.
void Internal::block_reschedule_clause (Blocker &blocker, int lit,
Clause *c) {
#ifdef NDEBUG
(void) lit;
#endif
assert (c->garbage);
for (const auto &other : *c) {
int64_t &n = noccs (other);
assert (n > 0);
n--;
LOG ("updating %d with %" PRId64 " positive and %" PRId64
" negative occurrences",
other, noccs (other), noccs (-other));
if (blocker.schedule.contains (vlit (-other)))
blocker.schedule.update (vlit (-other));
else if (active (other) && !frozen (other) && !marked_skip (-other)) {
LOG ("rescheduling to block clauses on %d", -other);
blocker.schedule.push_back (vlit (-other));
}
if (blocker.schedule.contains (vlit (other))) {
assert (other != lit);
blocker.schedule.update (vlit (other));
}
}
}
// Reschedule all literals in clauses blocked by 'lit' (except 'lit').
void Internal::block_reschedule (Blocker &blocker, int lit) {
while (!blocker.reschedule.empty ()) {
Clause *c = blocker.reschedule.back ();
blocker.reschedule.pop_back ();
block_reschedule_clause (blocker, lit, c);
}
}
/*------------------------------------------------------------------------*/
void Internal::block_literal (Blocker &blocker, int lit) {
assert (!marked_skip (lit));
if (!active (lit))
return; // Pure literal '-lit'.
if (frozen (lit))
return;
assert (!val (lit));
// If the maximum number of a negative clauses (with '-lit') exceeds the
// occurrence limit ignore this candidate literal.
//
if (noccs (-lit) > opts.blockocclim)
return;
LOG ("blocking literal candidate %d "
"with %" PRId64 " positive and %" PRId64 " negative occurrences",
lit, noccs (lit), noccs (-lit));
stats.blockcands++;
assert (blocker.reschedule.empty ());
assert (blocker.candidates.empty ());
if (!noccs (-lit))
block_pure_literal (blocker, lit);
else if (!noccs (lit)) {
// Rare situation, where the clause length limit was hit for 'lit' and
// '-lit' is skipped and then it becomes pure. Can be ignored. We also
// so it once happing for a 'elimboundmin=-1' and zero positive and one
// negative occurrence.
} else if (noccs (-lit) == 1)
block_literal_with_one_negative_occ (blocker, lit);
else
block_literal_with_at_least_two_negative_occs (blocker, lit);
// Done with blocked clause elimination on this literal and we do not
// have to try blocked clause elimination on it again until irredundant
// clauses with its negation are removed.
//
assert (!frozen (lit)); // just to be sure ...
unmark_block (lit);
}
/*------------------------------------------------------------------------*/
bool Internal::block () {
if (!opts.block)
return false;
if (unsat)
return false;
if (!stats.current.irredundant)
return false;
if (terminated_asynchronously ())
return false;
if (propagated < trail.size ()) {
LOG ("need to propagate %zd units first", trail.size () - propagated);
init_watches ();
connect_watches ();
if (!propagate ()) {
LOG ("propagating units results in empty clause");
learn_empty_clause ();
assert (unsat);
}
clear_watches ();
reset_watches ();
if (unsat)
return false;
}
START_SIMPLIFIER (block, BLOCK);
stats.blockings++;
LOG ("block-%" PRId64 "", stats.blockings);
assert (!level);
assert (!watching ());
assert (!occurring ());
mark_satisfied_clauses_as_garbage ();
init_occs (); // Occurrence lists for all literals.
init_noccs (); // Number of occurrences to avoid flushing garbage clauses.
Blocker blocker (this);
block_schedule (blocker);
int64_t blocked = stats.blocked;
int64_t resolutions = stats.blockres;
int64_t purelits = stats.blockpurelits;
int64_t pured = stats.blockpured;
while (!terminated_asynchronously () && !blocker.schedule.empty ()) {
int lit = u2i (blocker.schedule.front ());
blocker.schedule.pop_front ();
block_literal (blocker, lit);
block_reschedule (blocker, lit);
}
blocker.erase ();
reset_noccs ();
reset_occs ();
resolutions = stats.blockres - resolutions;
blocked = stats.blocked - blocked;
PHASE ("block", stats.blockings,
"blocked %" PRId64 " clauses in %" PRId64 " resolutions", blocked,
resolutions);
pured = stats.blockpured - pured;
purelits = stats.blockpurelits - purelits;
if (pured)
mark_redundant_clauses_with_eliminated_variables_as_garbage ();
if (purelits)
PHASE ("block", stats.blockings,
"found %" PRId64 " pure literals in %" PRId64 " clauses",
purelits, pured);
else
PHASE ("block", stats.blockings, "no pure literals found");
report ('b', !opts.reportall && !blocked);
STOP_SIMPLIFIER (block, BLOCK);
return blocked;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/block.hpp 0000664 0000000 0000000 00000001313 14501267155 0016261 0 ustar 00root root 0000000 0000000 #ifndef _block_hpp_INCLUDED
#define _block_hpp_INCLUDED
#include "heap.hpp" // Alphabetically after 'block.hpp'.
namespace CaDiCaL {
struct Internal;
struct block_more_occs_size {
Internal *internal;
block_more_occs_size (Internal *i) : internal (i) {}
bool operator() (unsigned a, unsigned b);
};
typedef heap BlockSchedule;
class Blocker {
friend struct Internal;
vector candidates;
vector reschedule;
BlockSchedule schedule;
Blocker (Internal *i) : schedule (block_more_occs_size (i)) {}
void erase () {
erase_vector (candidates);
erase_vector (reschedule);
schedule.erase ();
}
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/cadical.cpp 0000664 0000000 0000000 00000102237 14501267155 0016551 0 ustar 00root root 0000000 0000000 /*------------------------------------------------------------------------*/
// Do include 'internal.hpp' but try to minimize internal dependencies.
#include "internal.hpp"
#include "signal.hpp" // Separate, only need for apps.
/*------------------------------------------------------------------------*/
namespace CaDiCaL {
// A wrapper app which makes up the CaDiCaL stand alone solver. It in
// essence only consists of the 'App::main' function. So this class
// contains code, which is not required if only the library interface in
// the class 'Solver' is used (defined in 'cadical.hpp'). It further uses
// static data structures in order to have a signal handler catch signals.
//
// It is thus neither thread-safe nor reentrant. If you want to use
// multiple instances of the solver use the 'Solver' interface directly
// which is thread-safe and reentrant among different solver instances.
/*------------------------------------------------------------------------*/
class App : public Handler, public Terminator {
Solver *solver; // Global solver.
#ifndef __WIN32
// Command line options.
//
int time_limit; // '-t '
#endif
// Strictness of (DIMACS) parsing:
//
// 0 = force parsing and completely ignore header
// 1 = relaxed header handling (default)
// 2 = strict header handling
//
// To use '0' use '-f' of '--force'.
// To use '2' use '--strict'.
//
int force_strict_parsing;
bool force_writing;
static bool most_likely_existing_cnf_file (const char *path);
// Internal variables.
//
int max_var; // Set after parsing.
volatile bool timesup; // Asynchronous termination.
// Printing.
//
void print_usage (bool all = false);
void print_witness (FILE *);
#ifndef QUIET
void signal_message (const char *msg, int sig);
#endif
// Option handling.
//
bool set (const char *);
bool set (const char *, int);
int get (const char *);
bool verbose () { return get ("verbose") && !get ("quiet"); }
/*----------------------------------------------------------------------*/
// The actual initialization.
//
void init ();
// Terminator interface.
//
bool terminate () { return timesup; }
// Handler interface.
//
void catch_signal (int sig);
void catch_alarm ();
public:
App ();
~App ();
// Parse the arguments and run the solver.
//
int main (int arg, char **argv);
};
/*------------------------------------------------------------------------*/
void App::print_usage (bool all) {
printf ("usage: cadical [ ... ] [ ] ]\n"
"\n"
"where '' is one of the following common options:\n"
"\n");
if (!all) { // Print only a short list of common options.
printf (" -h print this short list of common options\n"
" --help print complete list of all options\n"
" --version print version\n"
"\n"
" -n do not print witness\n"
#ifndef QUIET
" -v increase verbosity\n"
" -q be quiet\n"
#endif
"\n"
#ifndef __WIN32
" -t set wall clock time limit\n"
#endif
);
} else { // Print complete list of all options.
printf (
" -h print alternatively only a list of common "
"options\n"
" --help print this complete list of all options\n"
" --version print version\n"
"\n"
" -n do not print witness (same as '--no-witness')\n"
#ifndef QUIET
" -v increase verbosity (see also '--verbose' below)\n"
" -q be quiet (same as '--quiet')\n"
#endif
#ifndef __WIN32
" -t set wall clock time limit\n"
#endif
"\n"
"Or '' is one of the less common options\n"
"\n"
" -L run local search initially (default '0' rounds)\n"
" -O increase limits by '2^' or '10^'\n"
" -P initial preprocessing (default '0' rounds)\n"
"\n"
"Note there is no separating space for the options above while "
"the\n"
"following options require a space after the option name:\n"
"\n"
" -c limit the number of conflicts (default "
"unlimited)\n"
" -d limit the number of decisions (default "
"unlimited)\n"
"\n"
" -o write simplified CNF in DIMACS format to file\n"
" -e write reconstruction/extension stack to file\n"
#ifdef LOGGING
" -l enable logging messages (same as '--log')\n"
#endif
"\n"
" --force | -f parsing broken DIMACS header and writing proofs\n"
" --strict strict parsing (no white space in header)\n"
"\n"
" -r read solution in competition output format\n"
" to check consistency of learned clauses\n"
" during testing and debugging\n"
"\n"
" -w write result including a potential witness\n"
" solution in competition format to the given "
"file\n"
"\n"
" --colors force colored output\n"
" --no-colors disable colored output to terminal\n"
" --no-witness do not print witness (see also '-n' above)\n"
"\n"
" --build print build configuration\n"
" --copyright print copyright information\n");
printf ("\n"
"There are pre-defined configurations of advanced internal "
"options:\n"
"\n");
solver->configurations ();
printf (
"\n"
"Or '' is one of the following advanced internal options:\n"
"\n");
solver->usage ();
fputs (
"\n"
"The internal options have their default value printed in "
"brackets\n"
"after their description. They can also be used in the form\n"
"'--' which is equivalent to '--=1' and in the form\n"
"'--no-' which is equivalent to '--=0'. One can also\n"
"use 'true' instead of '1', 'false' instead of '0', as well as\n"
"numbers with positive exponent such as '1e3' instead of '1000'.\n"
"\n"
"Alternatively option values can also be specified in the header\n"
"of the DIMACS file, e.g., 'c --elim=false', or through "
"environment\n"
"variables, such as 'CADICAL_ELIM=false'. The embedded options "
"in\n"
"the DIMACS file have highest priority, followed by command line\n"
"options and then values specified through environment "
"variables.\n",
stdout);
}
//------------------------------------------------------------------------
// Common to both complete and common option usage.
fputs (
"\n"
"The input is read from '' is given then a DRAT proof is written to that file.\n",
stdout);
//------------------------------------------------------------------------
// More explanations for complete option usage.
if (all) {
fputs (
"\n"
"If '',\n"
"also if '-' is used as input path name '' and '' is connected to a terminal.\n"
"\n"
"The input is assumed to be compressed if it is given explicitly\n"
"and has a '.gz', '.bz2', '.xz' or '.7z' suffix. The same "
"applies\n"
"to the output file. In order to use compression and "
"decompression\n"
"the corresponding utilities 'gzip', 'bzip', 'xz', and '7z' "
"(depending\n"
"on the format) are required and need to be installed on the "
"system.\n"
"The solver checks file type signatures though and falls back to\n"
"non-compressed file reading if the signature does not match.\n",
stdout);
}
}
/*------------------------------------------------------------------------*/
// Pretty print competition format witness with 'v' lines.
void App::print_witness (FILE *file) {
int c = 0, i = 0, tmp;
do {
if (!c)
fputc ('v', file), c = 1;
if (i++ == max_var)
tmp = 0;
else
tmp = solver->val (i) < 0 ? -i : i;
char str[32];
snprintf (str, sizeof str, " %d", tmp);
int l = strlen (str);
if (c + l > 78)
fputs ("\nv", file), c = 1;
fputs (str, file);
c += l;
} while (tmp);
if (c)
fputc ('\n', file);
}
/*------------------------------------------------------------------------*/
// Wrapper around option setting.
int App::get (const char *o) { return solver->get (o); }
bool App::set (const char *o, int v) { return solver->set (o, v); }
bool App::set (const char *arg) { return solver->set_long_option (arg); }
/*------------------------------------------------------------------------*/
bool App::most_likely_existing_cnf_file (const char *path) {
if (!File::exists (path))
return false;
if (has_suffix (path, ".dimacs"))
return true;
if (has_suffix (path, ".dimacs.gz"))
return true;
if (has_suffix (path, ".dimacs.xz"))
return true;
if (has_suffix (path, ".dimacs.bz2"))
return true;
if (has_suffix (path, ".dimacs.7z"))
return true;
if (has_suffix (path, ".dimacs.lzma"))
return true;
if (has_suffix (path, ".cnf"))
return true;
if (has_suffix (path, ".cnf.gz"))
return true;
if (has_suffix (path, ".cnf.xz"))
return true;
if (has_suffix (path, ".cnf.bz2"))
return true;
if (has_suffix (path, ".cnf.7z"))
return true;
if (has_suffix (path, ".cnf.lzma"))
return true;
return false;
}
/*------------------------------------------------------------------------*/
// Short-cut for errors to avoid a hard 'exit'.
#define APPERR(...) \
do { \
solver->error (__VA_ARGS__); \
} while (0)
/*------------------------------------------------------------------------*/
int App::main (int argc, char **argv) {
// Handle options which lead to immediate exit first.
if (argc == 2) {
const char *arg = argv[1];
if (!strcmp (arg, "-h")) {
print_usage ();
return 0;
} else if (!strcmp (arg, "--help")) {
print_usage (true);
return 0;
} else if (!strcmp (arg, "--version")) {
printf ("%s\n", CaDiCaL::version ());
return 0;
} else if (!strcmp (arg, "--build")) {
tout.disable ();
Solver::build (stdout, "");
return 0;
} else if (!strcmp (arg, "--copyright")) {
printf ("%s\n", copyright ());
return 0;
}
}
// Now initialize solver.
init ();
// Set all argument option values to not used yet.
const char *preprocessing_specified = 0, *optimization_specified = 0;
const char *read_solution_path = 0, *write_result_path = 0;
const char *dimacs_path = 0, *proof_path = 0;
bool proof_specified = false, dimacs_specified = false;
int optimize = 0, preprocessing = 0, localsearch = 0;
const char *output_path = 0, *extension_path = 0;
int conflict_limit = -1, decision_limit = -1;
const char *conflict_limit_specified = 0;
const char *decision_limit_specified = 0;
const char *localsearch_specified = 0;
#ifndef __MINGW32__
const char *time_limit_specified = 0;
#endif
bool witness = true, less = false;
const char *dimacs_name, *err;
for (int i = 1; i < argc; i++) {
if (!strcmp (argv[i], "-h") || !strcmp (argv[i], "--help") ||
!strcmp (argv[i], "--build") || !strcmp (argv[i], "--version") ||
!strcmp (argv[i], "--copyright")) {
APPERR ("can only use '%s' as single first option", argv[i]);
} else if (!strcmp (argv[i], "-")) {
if (proof_specified)
APPERR ("too many arguments");
else if (!dimacs_specified)
dimacs_specified = true;
else
proof_specified = true;
} else if (!strcmp (argv[i], "-r")) {
if (++i == argc)
APPERR ("argument to '-r' missing");
else if (read_solution_path)
APPERR ("multiple read solution file options '-r %s' and '-r %s'",
read_solution_path, argv[i]);
else
read_solution_path = argv[i];
} else if (!strcmp (argv[i], "-w")) {
if (++i == argc)
APPERR ("argument to '-w' missing");
else if (write_result_path)
APPERR ("multiple solution file options '-w %s' and '-w %s'",
write_result_path, argv[i]);
else
write_result_path = argv[i];
} else if (!strcmp (argv[i], "-o")) {
if (++i == argc)
APPERR ("argument to '-o' missing");
else if (output_path)
APPERR ("multiple output file options '-o %s' and '-o %s'",
output_path, argv[i]);
else if (!force_writing && most_likely_existing_cnf_file (argv[i]))
APPERR ("output file '%s' most likely existing CNF (use '-f')",
argv[i]);
else if (!File::writable (argv[i]))
APPERR ("output file '%s' not writable", argv[i]);
else
output_path = argv[i];
} else if (!strcmp (argv[i], "-e")) {
if (++i == argc)
APPERR ("argument to '-e' missing");
else if (extension_path)
APPERR ("multiple extension file options '-e %s' and '-e %s'",
extension_path, argv[i]);
else if (!force_writing && most_likely_existing_cnf_file (argv[i]))
APPERR ("extension file '%s' most likely existing CNF (use '-f')",
argv[i]);
else if (!File::writable (argv[i]))
APPERR ("extension file '%s' not writable", argv[i]);
else
extension_path = argv[i];
} else if (is_color_option (argv[i])) {
tout.force_colors ();
terr.force_colors ();
} else if (is_no_color_option (argv[i])) {
tout.force_no_colors ();
terr.force_no_colors ();
} else if (!strcmp (argv[i], "--witness") ||
!strcmp (argv[i], "--witness=true") ||
!strcmp (argv[i], "--witness=1"))
witness = true;
else if (!strcmp (argv[i], "-n") || !strcmp (argv[i], "--no-witness") ||
!strcmp (argv[i], "--witness=false") ||
!strcmp (argv[i], "--witness=0"))
witness = false;
else if (!strcmp (argv[i], "--less")) { // EXPERIMENTAL!
if (less)
APPERR ("multiple '--less' options");
else if (!isatty (1))
APPERR ("'--less' without '' connected to terminal");
else
less = true;
} else if (!strcmp (argv[i], "-c")) {
if (++i == argc)
APPERR ("argument to '-c' missing");
else if (conflict_limit_specified)
APPERR ("multiple conflict limits '-c %s' and '-c %s'",
conflict_limit_specified, argv[i]);
else if (!parse_int_str (argv[i], conflict_limit))
APPERR ("invalid argument in '-c %s'", argv[i]);
else if (conflict_limit < 0)
APPERR ("invalid conflict limit");
else
conflict_limit_specified = argv[i];
} else if (!strcmp (argv[i], "-d")) {
if (++i == argc)
APPERR ("argument to '-d' missing");
else if (decision_limit_specified)
APPERR ("multiple decision limits '-d %s' and '-d %s'",
decision_limit_specified, argv[i]);
else if (!parse_int_str (argv[i], decision_limit))
APPERR ("invalid argument in '-d %s'", argv[i]);
else if (decision_limit < 0)
APPERR ("invalid decision limit");
else
decision_limit_specified = argv[i];
}
#ifndef __WIN32
else if (!strcmp (argv[i], "-t")) {
if (++i == argc)
APPERR ("argument to '-t' missing");
else if (time_limit_specified)
APPERR ("multiple time limit '-t %s' and '-t %s'",
time_limit_specified, argv[i]);
else if (!parse_int_str (argv[i], time_limit))
APPERR ("invalid argument in '-d %s'", argv[i]);
else if (time_limit < 0)
APPERR ("invalid time limit");
else
time_limit_specified = argv[i];
}
#endif
#ifndef QUIET
else if (!strcmp (argv[i], "-q"))
set ("--quiet");
else if (!strcmp (argv[i], "-v"))
set ("verbose", get ("verbose") + 1);
#endif
#ifdef LOGGING
else if (!strcmp (argv[i], "-l"))
set ("--log");
#endif
else if (!strcmp (argv[i], "-f") || !strcmp (argv[i], "--force") ||
!strcmp (argv[i], "--force=1") ||
!strcmp (argv[i], "--force=true"))
force_strict_parsing = 0, force_writing = true;
else if (!strcmp (argv[i], "--strict") ||
!strcmp (argv[i], "--strict=1") ||
!strcmp (argv[i], "--strict=true"))
force_strict_parsing = 2;
else if (has_prefix (argv[i], "-O")) {
if (optimization_specified)
APPERR ("multiple optimization options '%s' and '%s'",
optimization_specified, argv[i]);
optimization_specified = argv[i];
if (!parse_int_str (argv[i] + 2, optimize))
APPERR ("invalid optimization option '%s'", argv[i]);
if (optimize < 0 || optimize > 31)
APPERR ("invalid argument in '%s' (expected '0..31')", argv[i]);
} else if (has_prefix (argv[i], "-P")) {
if (preprocessing_specified)
APPERR ("multiple preprocessing options '%s' and '%s'",
preprocessing_specified, argv[i]);
preprocessing_specified = argv[i];
if (!parse_int_str (argv[i] + 2, preprocessing))
APPERR ("invalid preprocessing option '%s'", argv[i]);
if (preprocessing < 0)
APPERR ("invalid argument in '%s' (expected non-negative number)",
argv[i]);
} else if (has_prefix (argv[i], "-L")) {
if (localsearch_specified)
APPERR ("multiple local search options '%s' and '%s'",
localsearch_specified, argv[i]);
localsearch_specified = argv[i];
if (!parse_int_str (argv[i] + 2, localsearch))
APPERR ("invalid local search option '%s'", argv[i]);
if (localsearch < 0)
APPERR ("invalid argument in '%s' (expected non-negative number)",
argv[i]);
} else if (has_prefix (argv[i], "--") &&
solver->is_valid_configuration (argv[i] + 2)) {
solver->configure (argv[i] + 2);
} else if (set (argv[i])) {
/* nothing do be done */
} else if (argv[i][0] == '-')
APPERR ("invalid option '%s'", argv[i]);
else if (proof_specified)
APPERR ("too many arguments");
else if (dimacs_specified) {
proof_path = argv[i];
proof_specified = true;
if (!force_writing && most_likely_existing_cnf_file (proof_path))
APPERR ("DRAT proof file '%s' most likely existing CNF (use '-f')",
proof_path);
else if (!File::writable (proof_path))
APPERR ("DRAT proof file '%s' not writable", proof_path);
} else
dimacs_specified = true, dimacs_path = argv[i];
}
/*----------------------------------------------------------------------*/
if (dimacs_specified && dimacs_path && !File::exists (dimacs_path))
APPERR ("DIMACS input file '%s' does not exist", dimacs_path);
if (read_solution_path && !File::exists (read_solution_path))
APPERR ("solution file '%s' does not exist", read_solution_path);
if (dimacs_specified && dimacs_path && proof_specified && proof_path &&
!strcmp (dimacs_path, proof_path) && strcmp (dimacs_path, "-"))
APPERR ("DIMACS input file '%s' also specified as DRAT proof file",
dimacs_path);
/*----------------------------------------------------------------------*/
// The '--less' option is not fully functional yet (it is also not
// mentioned in the 'usage' message yet). It only works as expected if
// you let the solver run until it exits. The goal is to have a similar
// experience as with 'git diff' if the terminal is too small for the
// printed messages, but this needs substantial hacking.
//
// TODO: add proper forking, waiting, signal catching & propagating ...
//
FILE *less_pipe;
if (less) {
assert (isatty (1));
less_pipe = popen ("less -r", "w");
if (!less_pipe)
APPERR ("could not execute and open pipe to 'less -r' command");
dup2 (fileno (less_pipe), 1);
} else
less_pipe = 0;
/*----------------------------------------------------------------------*/
if (read_solution_path && !get ("check"))
set ("--check");
#ifndef QUIET
if (!get ("quiet")) {
solver->section ("banner");
solver->message ("%sCaDiCaL SAT Solver%s", tout.bright_magenta_code (),
tout.normal_code ());
solver->message ("%s%s%s", tout.bright_magenta_code (), copyright (),
tout.normal_code ());
solver->message ();
CaDiCaL::Solver::build (stdout, "c ");
}
#endif
if (preprocessing > 0 || localsearch > 0 ||
#ifndef __WIN32
time_limit >= 0 ||
#endif
conflict_limit >= 0 || decision_limit >= 0) {
solver->section ("limit");
if (preprocessing > 0) {
solver->message (
"enabling %d initial rounds of preprocessing (due to '%s')",
preprocessing, preprocessing_specified);
solver->limit ("preprocessing", preprocessing);
}
if (localsearch > 0) {
solver->message (
"enabling %d initial rounds of local search (due to '%s')",
localsearch, localsearch_specified);
solver->limit ("localsearch", localsearch);
}
#ifndef __WIN32
if (time_limit >= 0) {
solver->message (
"setting time limit to %d seconds real time (due to '-t %s')",
time_limit, time_limit_specified);
Signal::alarm (time_limit);
solver->connect_terminator (this);
}
#endif
if (conflict_limit >= 0) {
solver->message (
"setting conflict limit to %d conflicts (due to '%s')",
conflict_limit, conflict_limit_specified);
bool succeeded = solver->limit ("conflicts", conflict_limit);
assert (succeeded), (void) succeeded;
}
if (decision_limit >= 0) {
solver->message (
"setting decision limit to %d decisions (due to '%s')",
decision_limit, decision_limit_specified);
bool succeeded = solver->limit ("decisions", decision_limit);
assert (succeeded), (void) succeeded;
}
}
if (verbose () || proof_specified)
solver->section ("proof tracing");
if (proof_specified) {
if (!proof_path) {
const bool force_binary = (isatty (1) && get ("binary"));
if (force_binary)
set ("--no-binary");
solver->message ("writing %s proof trace to %s''%s",
(get ("binary") ? "binary" : "non-binary"),
tout.green_code (), tout.normal_code ());
if (force_binary)
solver->message (
"connected to terminal thus non-binary proof forced");
solver->trace_proof (stdout, "");
} else if (!solver->trace_proof (proof_path))
APPERR ("can not open and write DRAT proof to '%s'", proof_path);
else
solver->message ("writing %s proof trace to %s'%s'%s",
(get ("binary") ? "binary" : "non-binary"),
tout.green_code (), proof_path, tout.normal_code ());
} else
solver->verbose (1, "will not generate nor write DRAT proof");
solver->section ("parsing input");
dimacs_name = dimacs_path ? dimacs_path : "";
string help;
if (!dimacs_path) {
help += " ";
help += tout.magenta_code ();
help += "(use '-h' for a list of common options)";
help += tout.normal_code ();
}
solver->message ("reading DIMACS file from %s'%s'%s%s",
tout.green_code (), dimacs_name, tout.normal_code (),
help.c_str ());
bool incremental;
vector cube_literals;
if (dimacs_path)
err = solver->read_dimacs (dimacs_path, max_var, force_strict_parsing,
incremental, cube_literals);
else
err = solver->read_dimacs (stdin, dimacs_name, max_var,
force_strict_parsing, incremental,
cube_literals);
if (err)
APPERR ("%s", err);
if (read_solution_path) {
solver->section ("parsing solution");
solver->message ("reading solution file from '%s'", read_solution_path);
if ((err = solver->read_solution (read_solution_path)))
APPERR ("%s", err);
}
solver->section ("options");
if (optimize > 0) {
solver->optimize (optimize);
solver->message ();
}
solver->options ();
int res = 0;
if (incremental) {
bool reporting = get ("report") > 1 || get ("verbose") > 0;
if (!reporting)
set ("report", 0);
if (!reporting)
solver->section ("incremental solving");
size_t cubes = 0, solved = 0;
size_t satisfiable = 0, unsatisfiable = 0, inconclusive = 0;
#ifndef QUIET
bool quiet = get ("quiet");
struct {
double start, delta, sum;
} time = {0, 0, 0};
#endif
for (auto lit : cube_literals)
if (!lit)
cubes++;
if (!reporting) {
if (cubes)
solver->message ("starting to solve %zu cubes", cubes),
solver->message ();
else
solver->message ("no cube to solve");
}
vector cube, failed;
for (auto lit : cube_literals) {
if (lit)
cube.push_back (lit);
else {
reverse (cube.begin (), cube.end ());
for (auto other : cube)
solver->assume (other);
if (solved++) {
if (conflict_limit >= 0)
(void) solver->limit ("conflicts", conflict_limit);
if (decision_limit >= 0)
(void) solver->limit ("decisions", decision_limit);
}
#ifndef QUIET
char buffer[256];
if (!quiet) {
if (reporting) {
snprintf (buffer, sizeof buffer,
"solving cube %zu / %zu %.0f%%", solved, cubes,
percent (solved, cubes));
solver->section (buffer);
}
time.start = absolute_process_time ();
}
#endif
res = solver->solve ();
#ifndef QUIET
if (!quiet) {
time.delta = absolute_process_time () - time.start;
time.sum += time.delta;
snprintf (buffer, sizeof buffer,
"%s"
"in %.3f sec "
"(%.0f%% after %.2f sec at %.0f ms/cube)"
"%s",
tout.magenta_code (), time.delta,
percent (solved, cubes), time.sum,
relative (1e3 * time.sum, solved), tout.normal_code ());
if (reporting)
solver->message ();
const char *cube_str, *status_str, *color_code;
if (res == 10) {
cube_str = "CUBE";
color_code = tout.green_code ();
status_str = "SATISFIABLE";
} else if (res == 20) {
cube_str = "CUBE";
color_code = tout.cyan_code ();
status_str = "UNSATISFIABLE";
} else {
cube_str = "cube";
color_code = tout.magenta_code ();
status_str = "inconclusive";
}
const char *fmt;
if (reporting)
fmt = "%s%s %zu %s%s %s";
else
fmt = "%s%s %zu %-13s%s %s";
solver->message (fmt, color_code, cube_str, solved, status_str,
tout.normal_code (), buffer);
}
#endif
if (res == 10) {
satisfiable++;
break;
} else if (res == 20) {
unsatisfiable++;
for (auto other : cube)
if (solver->failed (other))
failed.push_back (other);
for (auto other : failed)
solver->add (-other);
solver->add (0);
failed.clear ();
} else {
assert (!res);
inconclusive++;
if (timesup)
break;
}
cube.clear ();
}
}
solver->section ("incremental summary");
solver->message ("%zu cubes solved %.0f%%", solved,
percent (solved, cubes));
solver->message ("%zu cubes inconclusive %.0f%%", inconclusive,
percent (inconclusive, solved));
solver->message ("%zu cubes unsatisfiable %.0f%%", unsatisfiable,
percent (unsatisfiable, solved));
solver->message ("%zu cubes satisfiable %.0f%%", satisfiable,
percent (satisfiable, solved));
if (inconclusive && res == 20)
res = 0;
} else {
solver->section ("solving");
res = solver->solve ();
}
if (proof_specified) {
solver->section ("closing proof");
solver->flush_proof_trace ();
solver->close_proof_trace ();
}
if (output_path) {
solver->section ("writing output");
solver->message ("writing simplified CNF to DIMACS file %s'%s'%s",
tout.green_code (), output_path, tout.normal_code ());
err = solver->write_dimacs (output_path, max_var);
if (err)
APPERR ("%s", err);
}
if (extension_path) {
solver->section ("writing extension");
solver->message ("writing extension stack to %s'%s'%s",
tout.green_code (), extension_path,
tout.normal_code ());
err = solver->write_extension (extension_path);
if (err)
APPERR ("%s", err);
}
solver->section ("result");
FILE *write_result_file;
write_result_file = stdout;
if (write_result_path) {
write_result_file = fopen (write_result_path, "w");
if (!write_result_file)
APPERR ("could not write solution to '%s'", write_result_path);
solver->message ("writing result to '%s'", write_result_path);
}
if (res == 10) {
fputs ("s SATISFIABLE\n", write_result_file);
if (witness)
print_witness (write_result_file);
} else if (res == 20)
fputs ("s UNSATISFIABLE\n", write_result_file);
else
fputs ("c UNKNOWN\n", write_result_file);
fflush (write_result_file);
if (write_result_path)
fclose (write_result_file);
solver->statistics ();
solver->resources ();
solver->section ("shutting down");
solver->message ("exit %d", res);
if (less_pipe) {
close (1);
pclose (less_pipe);
}
#ifndef __WIN32
if (time_limit > 0)
alarm (0);
#endif
return res;
}
/*------------------------------------------------------------------------*/
// The real initialization is delayed.
void App::init () {
assert (!solver);
#ifndef __WIN32
time_limit = -1;
#endif
force_strict_parsing = 1;
force_writing = false;
max_var = 0;
timesup = false;
// Call 'new Solver' only after setting 'reportdefault' and do not
// add this call to the member initialization above. This is because for
// stand-alone usage the default report default value is 'true' while for
// library usage it should remain 'false'. See the explanation in
// 'options.hpp' related to 'reportdefault' for details.
CaDiCaL::Options::reportdefault = 1;
solver = new Solver ();
Signal::set (this);
}
/*------------------------------------------------------------------------*/
App::App () : solver (0) {} // Only partially initialize the app.
App::~App () {
if (!solver)
return; // Only partially initialized.
Signal::reset ();
delete solver;
}
/*------------------------------------------------------------------------*/
#ifndef QUIET
void App::signal_message (const char *msg, int sig) {
solver->message ("%s%s %ssignal %d%s (%s)%s", tout.red_code (), msg,
tout.bright_red_code (), sig, tout.red_code (),
Signal::name (sig), tout.normal_code ());
}
#endif
void App::catch_signal (int sig) {
#ifndef QUIET
if (!get ("quiet")) {
solver->message ();
signal_message ("caught", sig);
solver->section ("result");
solver->message ("UNKNOWN");
solver->statistics ();
solver->resources ();
solver->message ();
signal_message ("raising", sig);
}
#else
(void) sig;
#endif
}
void App::catch_alarm () {
// Both approaches work. We keep them here for illustration purposes.
#if 0 // THIS IS AN ALTERNATIVE WE WANT TO KEEP AROUND.
solver->terminate (); // Immediate asynchronous call into solver.
#else
timesup = true; // Wait for solver to call 'App::terminate ()'.
#endif
}
} // namespace CaDiCaL
/*------------------------------------------------------------------------*/
// The actual app is allocated on the stack and then its 'main' function is
// called. This looks like that there are no static variables, which is not
// completely true, since both the signal handler connected to the app as
// well as the terminal have statically allocated components as well as the
// options table 'Options::table'. All are shared among solvers.
int main (int argc, char **argv) {
CaDiCaL::App app;
int res = app.main (argc, argv);
return res;
}
cadical-rel-1.7.4/src/cadical.hpp 0000664 0000000 0000000 00000125650 14501267155 0016562 0 ustar 00root root 0000000 0000000 #ifndef _cadical_hpp_INCLUDED
#define _cadical_hpp_INCLUDED
#include
#include
#include
namespace CaDiCaL {
/*========================================================================*/
// This provides the actual API of the CaDiCaL solver, which is implemented
// in the class 'Solver' below. Beside its constructor and destructor most
// important is the IPASIR part which you can find between 'BEGIN IPASIR'
// and 'END IPASIR' comments below. The following '[Example]' below might
// also be a good starting point to understand the API.
/*========================================================================*/
// [Example]
//
// The internal solver state follows the IPASIR API model used in the
// incremental track of the SAT competition. State transitions are
// triggered by member function calls, declared and described below.
//
// Consider the following code (from 'test/api/example.cpp') of API usage:
//
// CaDiCaL::Solver * solver = new CaDiCaL::Solver;
//
// // ------------------------------------------------------------------
// // Encode Problem and check without assumptions.
//
// enum { TIE = 1, SHIRT = 2 };
//
// solver->add (-TIE), solver->add (SHIRT), solver->add (0);
// solver->add (TIE), solver->add (SHIRT), solver->add (0);
// solver->add (-TIE), solver->add (-SHIRT), solver->add (0);
//
// int res = solver->solve (); // Solve instance.
// assert (res == 10); // Check it is 'SATISFIABLE'.
//
// res = solver->val (TIE); // Obtain assignment of 'TIE'.
// assert (res < 0); // Check 'TIE' assigned to 'false'.
//
// res = solver->val (SHIRT); // Obtain assignment of 'SHIRT'.
// assert (res > 0); // Check 'SHIRT' assigned to 'true'.
//
// // ------------------------------------------------------------------
// // Incrementally solve again under one assumption.
//
// solver->assume (TIE); // Now force 'TIE' to true.
//
// res = solver->solve (); // Solve again incrementally.
// assert (res == 20); // Check it is 'UNSATISFIABLE'.
//
// res = solver->failed (TIE); // Check 'TIE' responsible.
// assert (res); // Yes, 'TIE' in core.
//
// res = solver->failed (SHIRT); // Check 'SHIRT' responsible.
// assert (!res); // No, 'SHIRT' not in core.
//
// // ------------------------------------------------------------------
// // Incrementally solve once more under another assumption.
//
// solver->assume (-SHIRT); // Now force 'SHIRT' to false.
//
// res = solver->solve (); // Solve again incrementally.
// assert (res == 20); // Check it is 'UNSATISFIABLE'.
//
// res = solver->failed (TIE); // Check 'TIE' responsible.
// assert (!res); // No, 'TIE' not in core.
//
// res = solver->failed (-SHIRT); // Check '!SHIRT' responsible.
// assert (res); // Yes, '!SHIRT' in core.
//
// // ------------------------------------------------------------------
//
// delete solver;
/*========================================================================*/
// [States and Transitions]
//
// Compared to IPASIR we also use an 'ADDING' state in which the solver
// stays while adding non-zero literals until the clause is completed
// through adding a zero literal. The additional 'INITIALIZING',
// 'CONFIGURING' and 'DELETING' states are also not part of IPASIR but also
// useful for testing and debugging.
//
// We have the following transitions which are all synchronous except for
// the reentrant 'terminate' call:
//
// new
// INITIALIZING --------------------------> CONFIGURING
//
// set / trace
// CONFIGURING --------------------------> CONFIGURING
//
// add (non zero literal)
// VALID --------------------------> ADDING
//
// add (zero literal)
// VALID --------------------------> UNKNOWN
//
// assume (non zero literal)
// READY --------------------------> UNKNOWN
//
// solve
// READY --------------------------> SOLVING
//
// (internal)
// SOLVING --------------------------> READY
//
// val (non zero literal)
// SATISFIED --------------------------> SATISFIED
//
// failed (non zero literal )
// UNSATISFIED --------------------------> UNSATISFIED
//
// delete
// VALID --------------------------> DELETING
//
// where
//
// READY = CONFIGURING | UNKNOWN | SATISFIED | UNSATISFIED
// VALID = READY | ADDING
// INVALID = INITIALIZING | DELETING
//
// The 'SOLVING' state is only visible in different contexts, i.e., from
// another thread or from a signal handler. It is used to implement
// 'terminate'. Here is the only asynchronous transition:
//
// terminate (asynchronously)
// SOLVING -------------------------> UNKNOWN
//
// The important behaviour to remember is that adding, assuming or
// constraining a literal (immediately) destroys the satisfying assignment
// in the 'SATISFIED' state and vice versa resets all assumptions in the
// 'UNSATISFIED' state. This is exactly the behaviour required by the IPASIR
// interface.
//
// Furthermore, the model can only be queried through 'val' in the
// 'SATISFIED' state, while extracting failed assumptions with 'failed' only
// in the 'UNSATISFIED' state. Solving can only be started in the 'UNKNOWN'
// or 'CONFIGURING' state or after the previous call to 'solve' yielded an
// 'UNKNOWN, 'SATISFIED' or 'UNSATISFIED' state.
//
// All literals have to be valid literals too, i.e., 32-bit integers
// different from 'INT_MIN'. If any of these requirements is violated the
// solver aborts with an 'API contract violation' message.
//
// HINT: If you do not understand why a contract is violated you can run
// 'mobical' on the failing API call trace. Point the environment variable
// 'CADICAL_API_TRACE' to the file where you want to save the trace during
// execution of your program linking against the library. You probably need
// for 'mobical' to use the option '--do-not-enforce-contracts' though to
// force running into the same contract violation.
//
// Additional API calls (like 'freeze' and 'melt') do not change the state
// of the solver and are all described below.
/*========================================================================*/
// States are represented by a bit-set in order to combine them.
enum State {
INITIALIZING = 1, // during initialization (invalid)
CONFIGURING = 2, // configure options (with 'set')
UNKNOWN = 4, // ready to call 'solve'
ADDING = 8, // adding clause literals (zero missing)
SOLVING = 16, // while solving (within 'solve')
SATISFIED = 32, // satisfiable allows 'val'
UNSATISFIED = 64, // unsatisfiable allows 'failed'
DELETING = 128, // during and after deletion (invalid)
// These combined states are used to check contracts.
READY = CONFIGURING | UNKNOWN | SATISFIED | UNSATISFIED,
VALID = READY | ADDING,
INVALID = INITIALIZING | DELETING
};
/*------------------------------------------------------------------------*/
// Opaque classes needed in the API and declared in the same namespace.
class File;
struct Internal;
struct External;
/*------------------------------------------------------------------------*/
// Forward declaration of call-back classes. See bottom of this file.
class Learner;
class Terminator;
class ClauseIterator;
class WitnessIterator;
class ExternalPropagator;
/*------------------------------------------------------------------------*/
class Solver {
public:
// ====== BEGIN IPASIR ===================================================
// This section implements the corresponding IPASIR functionality.
Solver ();
~Solver ();
static const char *signature (); // name of this library
// Core functionality as in the IPASIR incremental SAT solver interface.
// (recall 'READY = CONFIGURING | UNKNOWN | SATISFIED | UNSATISFIED').
// Further note that 'lit' is required to be different from 'INT_MIN' and
// different from '0' except for 'add'.
// Add valid literal to clause or zero to terminate clause.
//
// require (VALID) // recall 'VALID = READY | ADDING'
// if (lit) ensure (ADDING) // and thus VALID but not READY
// if (!lit) ensure (UNKNOWN) // and thus READY
//
void add (int lit);
bool inconsistent ();
// Assume valid non zero literal for next call to 'solve'. These
// assumptions are reset after the call to 'solve' as well as after
// returning from 'simplify' and 'lookahead.
//
// require (READY)
// ensure (UNKNOWN)
//
void assume (int lit);
// Try to solve the current formula. Returns
//
// 0 = UNSOLVED (limit reached or interrupted through 'terminate')
// 10 = SATISFIABLE
// 20 = UNSATISFIABLE
//
// require (READY)
// ensure (UNKNOWN | SATISFIED | UNSATISFIED)
//
// Note, that while in this call the solver actually transitions to state
// 'SOLVING', which however is only visible from a different context,
// i.e., from a different thread or from a signal handler. Only right
// before returning from this call it goes into a 'READY' state.
//
int solve ();
// Get value (-lit=false, lit=true) of valid non-zero literal.
//
// require (SATISFIED)
// ensure (SATISFIED)
//
int val (int lit);
// Try to flip the value of the given literal without falsifying the
// formula. Returns 'true' if this was successful. Otherwise the model is
// not changed and 'false' is returned. If a literal was eliminated or
// substituted flipping will fail on that literal and in particular the
// solver will not taint it nor restore any clauses.
//
// The 'flip' function can only flip the value of a variables not acting
// as witness on the reconstruction stack.
//
// As a side effect of calling this function first all assigned variables
// are propagated again without using blocking literal. Thus the first
// call to this function after obtaining a model adds a substantial
// overhead. Subsequent calls will not need to properly propagate again.
//
// Furthermore if the reconstruction stack is non-empty and has been
// traversed to reconstruct a full extended model for eliminated
// variables (and to satisfy removed blocked clauses), the values of these
// witness variables obtained via 'val' before become invalid. The user
// thus will need to call 'val' again after calling 'flip' which will
// trigger then a traversal of the reconstruction stack.
//
// So try to avoid mixing 'flip' and 'val' (for efficiency only).
// Further, this functionality is currently not supported in the presence
// of an external propagator.
//
// require (SATISFIED)
// ensure (SATISFIED)
//
bool flip (int lit);
// Same as 'flip' without actually flipping it. This functionality is
// currently not supported in the presence of an external propagator.
//
// require (SATISFIED)
// ensure (SATISFIED)
//
bool flippable (int lit);
// Determine whether the valid non-zero literal is in the core.
// Returns 'true' if the literal is in the core and 'false' otherwise.
// Note that the core does not have to be minimal.
//
// require (UNSATISFIED)
// ensure (UNSATISFIED)
//
bool failed (int lit);
// Add call-back which is checked regularly for termination. There can
// only be one terminator connected. If a second (non-zero) one is added
// the first one is implicitly disconnected.
//
// require (VALID)
// ensure (VALID)
//
void connect_terminator (Terminator *terminator);
void disconnect_terminator ();
// Add call-back which allows to export learned clauses.
//
// require (VALID)
// ensure (VALID)
//
void connect_learner (Learner *learner);
void disconnect_learner ();
// ====== END IPASIR =====================================================
// ====== BEGIN IPASIR-UP ================================================
// Add call-back which allows to learn, propagate and backtrack based on
// external constraints. Only one external propagator can be connected
// and after connection every related variables must be 'observed' (use
// 'add_observed_var' function).
// Disconnection of the external propagator resets all the observed
// variables.
//
// require (VALID)
// ensure (VALID)
//
void connect_external_propagator (ExternalPropagator *propagator);
void disconnect_external_propagator ();
// Mark as 'observed' those variables that are relevant to the external
// propagator. External propagation, clause addition during search and
// notifications are all over these observed variabes.
// A variable can not be observed witouth having an external propagator
// connected. Observed variables are "frozen" internally, and so
// inprocessing will not consider them as candidates for elimination.
// An observed variable is allowed to be a fresh variable and it can be
// added also during solving.
//
// require (VALID_OR_SOLVING)
// ensure (VALID_OR_SOLVING)
//
void add_observed_var (int var);
// Removes the 'observed' flag from the given variable. A variable can be
// set unobserved only between solve calls, not during it (to guarantee
// that no yet unexplained external propagation involves it).
//
// require (VALID)
// ensure (VALID)
//
void remove_observed_var (int var);
// Removes all the 'observed' flags from the variables. Disconnecting the
// propagator invokes this step as well.
//
// require (VALID)
// ensure (VALID)
//
void reset_observed_vars ();
// Get reason of valid observed literal (true = it is an observed variable
// and it got assigned by a decision during the CDCL loop. Otherwise:
// false.
//
// require (VALID_OR_SOLVING)
// ensure (VALID_OR_SOLVING)
//
bool is_decision (int lit);
// ====== END IPASIR-UP ==================================================
//------------------------------------------------------------------------
// Adds a literal to the constraint clause. Same functionality as 'add'
// but the clause only exists for the next call to solve (same lifetime as
// assumptions). Only one constraint may exists at a time. A new
// constraint replaces the old. The main application of this functonality
// is the model checking algorithm IC3. See our FMCAD'21 paper
// [FroleyksBiere-FMCAD'19] for more details.
//
// Add valid literal to the constraint clause or zero to terminate it.
//
// require (VALID) // recall 'VALID = READY |
// ADDING' if (lit) ensure (ADDING) // and thus VALID but not
// READY if (!lit) && !adding_clause ensure (UNKNOWN) // and thus READY
//
void constrain (int lit);
// Determine whether the constraint was used to proof the
// unsatisfiability. Note that the formula might still be unsatisfiable
// without the constraint.
//
// require (UNSATISFIED)
// ensure (UNSATISFIED)
//
bool constraint_failed ();
//------------------------------------------------------------------------
// This function determines a good splitting literal. The result can be
// zero if the formula is proven to be satisfiable or unsatisfiable. This
// can then be checked by 'state ()'. If the formula is empty and
// the function is not able to determine satisfiability also zero is
// returned but the state remains unknown.
//
// require (READY)
// ensure (UNKNOWN|SATISFIED|UNSATISFIED)
//
int lookahead (void);
struct CubesWithStatus {
int status;
std::vector> cubes;
};
CubesWithStatus generate_cubes (int, int min_depth = 0);
void reset_assumptions ();
void reset_constraint ();
// Return the current state of the solver as defined above.
//
const State &state () const { return _state; }
// Similar to 'state ()' but using the staddard competition exit codes of
// '10' for 'SATISFIABLE', '20' for 'UNSATISFIABLE' and '0' otherwise.
//
int status () const {
if (_state == SATISFIED)
return 10;
else if (_state == UNSATISFIED)
return 20;
else
return 0;
}
/*----------------------------------------------------------------------*/
static const char *version (); // return version string
/*----------------------------------------------------------------------*/
// Copy 'this' into a fresh 'other'. The copy procedure is not a deep
// clone, but only copies irredundant clauses and units. It also makes
// sure that witness reconstruction works with the copy as with the
// original formula such that both solvers have the same models.
// Assumptions are not copied. Options however are copied as well as
// flags which remember the current state of variables in preprocessing.
//
// require (READY) // for 'this'
// ensure (READY) // for 'this'
//
// other.require (CONFIGURING)
// other.ensure (CONFIGURING | UNKNOWN)
//
void copy (Solver &other) const;
/*----------------------------------------------------------------------*/
// Variables are usually added and initialized implicitly whenever a
// literal is used as an argument except for the functions 'val', 'fixed',
// 'failed' and 'frozen'. However, the library internally keeps a maximum
// variable index, which can be queried.
//
// require (VALID | SOLVING)
// ensure (VALID | SOLVING)
//
int vars ();
// Increase the maximum variable index explicitly. This function makes
// sure that at least 'min_max_var' variables are initialized. Since it
// might need to reallocate tables, it destroys a satisfying assignment
// and has the same state transition and conditions as 'assume' etc.
//
// require (READY)
// ensure (UNKNOWN)
//
void reserve (int min_max_var);
#ifndef NTRACING
//------------------------------------------------------------------------
// This function can be used to write API calls to a file. The same
// format is used which 'mobical' can read, execute and also shrink
// through delta debugging.
//
// Tracing API calls can also be achieved by using the environment
// variable 'CADICAL_API_TRACE'. That alternative is useful if you do not
// want to change the source code using the solver, e.g., if you only have
// a binary with the solver linked in. However, that method only allows
// to trace one solver instance, while with the following function API
// tracing can be enabled for different solver instances individually.
//
// The solver will flush the file after every trace API call but does not
// close it during deletion. It remains owned by the user of the library.
//
// require (VALID)
// ensure (VALID)
//
void trace_api_calls (FILE *file);
#endif
//------------------------------------------------------------------------
// Option handling.
// Determine whether 'name' is a valid option name.
//
static bool is_valid_option (const char *name);
// Determine whether 'name' enables a specific preprocessing technique.
//
static bool is_preprocessing_option (const char *name);
// Determine whether 'arg' is a valid long option of the form '--',
// '--=' or '--no-' similar to 'set_long_option' below.
// Legal values are 'true', 'false', or '[-][e]'.
static bool is_valid_long_option (const char *arg);
// Get the current value of the option 'name'. If 'name' is invalid then
// zero is returned. Here '--...' arguments as invalid options.
//
int get (const char *name);
// Set the default verbose message prefix (default "c ").
//
void prefix (const char *verbose_message_prefix);
// Explicit version of setting an option. If the option '' exists
// and '' can be parsed then 'true' is returned. If the option value
// is out of range the actual value is computed as the closest (minimum or
// maximum) value possible, but still 'true' is returned.
//
// require (CONFIGURING)
// ensure (CONFIGURING)
//
// Thus options can only bet set right after initialization.
//
bool set (const char *name, int val);
// This function accepts options in command line syntax:
//
// '--=', '--', or '--no-'
//
// It actually calls the previous 'set' function after parsing 'arg'. The
// same values are expected as for 'is_valid_long_option' above and as
// with 'set' any value outside of the range of legal values for a
// particular option are set to either the minimum or maximum depending on
// which side of the valid interval they lie.
//
// require (CONFIGURING)
// ensure (CONFIGURING)
//
bool set_long_option (const char *arg);
// Determine whether 'name' is a valid configuration.
//
static bool is_valid_configuration (const char *);
// Overwrite (some) options with the forced values of the configuration.
// The result is 'true' iff the 'name' is a valid configuration.
//
// require (CONFIGURING)
// ensure (CONFIGURING)
//
bool configure (const char *);
// Increase preprocessing and inprocessing limits by '10^'. Values
// below '0' are ignored and values above '9' are reduced to '9'.
//
// require (READY)
// ensure (READY)
//
void optimize (int val);
// Specify search limits, where currently 'name' can be "conflicts",
// "decisions", "preprocessing", or "localsearch". The first two limits
// are unbounded by default. Thus using a negative limit for conflicts or
// decisions switches back to the default of unlimited search (for that
// particular limit). The preprocessing limit determines the number of
// preprocessing rounds, which is zero by default. Similarly, the local
// search limit determines the number of local search rounds (also zero by
// default). As with 'set', the return value denotes whether the limit
// 'name' is valid. These limits are only valid for the next 'solve' or
// 'simplify' call and reset to their default after 'solve' returns (as
// well as overwritten and reset during calls to 'simplify' and
// 'lookahead'). We actually also have an internal "terminate" limit
// which however should only be used for testing and debugging.
//
// require (READY)
// ensure (READY)
//
bool limit (const char *arg, int val);
bool is_valid_limit (const char *arg);
// The number of currently active variables and clauses can be queried by
// these functions. Variables become active if a clause is added with it.
// They become inactive if they are eliminated or fixed at the root level
// Clauses become inactive if they are satisfied, subsumed, eliminated.
// Redundant clauses are reduced regularly and thus the 'redundant'
// function is less useful.
//
// require (VALID)
// ensure (VALID)
//
int active () const; // Number of active variables.
int64_t redundant () const; // Number of active redundant clauses.
int64_t irredundant () const; // Number of active irredundant clauses.
//------------------------------------------------------------------------
// This function executes the given number of preprocessing rounds. It is
// similar to 'solve' with 'limits ("preprocessing", rounds)' except that
// no CDCL nor local search, nor lucky phases are executed. The result
// values are also the same: 0=unknown, 10=satisfiable, 20=unsatisfiable.
// As 'solve' it resets current assumptions and limits before returning.
// The numbers of rounds should not be negative. If the number of rounds
// is zero only clauses are restored (if necessary) and top level unit
// propagation is performed, which both take some time.
//
// require (READY)
// ensure (UNKNOWN | SATISFIED | UNSATISFIED)
//
int simplify (int rounds = 3);
//------------------------------------------------------------------------
// Force termination of 'solve' asynchronously.
//
// require (SOLVING | READY)
// ensure (UNKNOWN) // actually not immediately (synchronously)
//
void terminate ();
//------------------------------------------------------------------------
// We have the following common reference counting functions, which avoid
// to restore clauses but require substantial user guidance. This was the
// only way to use inprocessing in incremental SAT solving in Lingeling
// (and before in MiniSAT's 'freeze' / 'thaw') and which did not use
// automatic clause restoring. In general this is slower than
// restoring clauses and should not be used.
//
// In essence the user freezes variables which potentially are still
// needed in clauses added or assumptions used after the next 'solve'
// call. As in Lingeling you can freeze a variable multiple times, but
// then have to melt it the same number of times again in order to enable
// variable eliminating on it etc. The arguments can be literals
// (negative indices) but conceptually variables are frozen.
//
// In the old way of doing things without restore you should not use a
// variable incrementally (in 'add' or 'assume'), which was used before
// and potentially could have been eliminated in a previous 'solve' call.
// This can lead to spurious satisfying assignment. In order to check
// this API contract one can use the 'checkfrozen' option. This has the
// drawback that restoring clauses implicitly would fail with a fatal
// error message even if in principle the solver could just restore
// clauses. Thus this option is disabled by default.
//
// See our SAT'19 paper [FazekasBiereScholl-SAT'19] for more details.
//
// require (VALID)
// ensure (VALID)
//
bool frozen (int lit) const;
void freeze (int lit);
void melt (int lit); // Also needs 'require (frozen (lit))'.
//------------------------------------------------------------------------
// Root level assigned variables can be queried with this function.
// It returns '1' if the literal is implied by the formula, '-1' if its
// negation is implied, or '0' if this is unclear at this point.
//
// require (VALID)
// ensure (VALID)
//
int fixed (int lit) const;
//------------------------------------------------------------------------
// Force the default decision phase of a variable to a certain value.
//
void phase (int lit);
void unphase (int lit);
//------------------------------------------------------------------------
// Enables clausal proof tracing in DRAT format and returns 'true' if
// successfully opened for writing. Writing proofs has to be enabled
// before calling 'solve', 'add' and 'dimacs', that is in state
// 'CONFIGURING'. Otherwise only partial proofs would be written.
//
// require (CONFIGURING)
// ensure (CONFIGURING)
//
bool trace_proof (FILE *file, const char *name); // Write DRAT proof.
bool trace_proof (const char *path); // Open & write proof.
// Flush proof trace file.
//
// require (VALID)
// ensure (VALID)
//
void flush_proof_trace ();
// Close proof trace early.
//
// require (VALID)
// ensure (VALID)
//
void close_proof_trace ();
//------------------------------------------------------------------------
static void usage (); // print usage information for long options
static void configurations (); // print configuration usage options
// require (!DELETING)
// ensure (!DELETING)
//
void statistics (); // print statistics
void resources (); // print resource usage (time and memory)
// require (VALID)
// ensure (VALID)
//
void options (); // print current option and value list
//------------------------------------------------------------------------
// Traverse irredundant clauses or the extension stack in reverse order.
//
// The return value is false if traversal is aborted early due to one of
// the visitor functions returning false. See description of the
// iterators below for more details on how to use these functions.
//
// require (VALID)
// ensure (VALID)
//
bool traverse_clauses (ClauseIterator &) const;
bool traverse_witnesses_backward (WitnessIterator &) const;
bool traverse_witnesses_forward (WitnessIterator &) const;
//------------------------------------------------------------------------
// Files with explicit path argument support compressed input and output
// if appropriate helper functions 'gzip' etc. are available. They are
// called through opening a pipe to an external command.
//
// If the 'strict' argument is zero then the number of variables and
// clauses specified in the DIMACS headers are ignored, i.e., the header
// 'p cnf 0 0' is always legal. If the 'strict' argument is larger '1'
// strict formatting of the header is required, i.e., single spaces
// everywhere and no trailing white space.
//
// Returns zero if successful and otherwise an error message.
//
// require (VALID)
// ensure (VALID)
//
const char *read_dimacs (FILE *file, const char *name, int &vars,
int strict = 1);
const char *read_dimacs (const char *path, int &vars, int strict = 1);
// The following routines work the same way but parse both DIMACS and
// INCCNF files (with 'p inccnf' header and 'a ' lines). If the
// parser finds and 'p inccnf' header or cubes then '*incremental' is set
// to true and the cubes are stored in the given vector (each cube
// terminated by a zero).
const char *read_dimacs (FILE *file, const char *name, int &vars,
int strict, bool &incremental,
std::vector &cubes);
const char *read_dimacs (const char *path, int &vars, int strict,
bool &incremental, std::vector &cubes);
//------------------------------------------------------------------------
// Write current irredundant clauses and all derived unit clauses
// to a file in DIMACS format. Clauses on the extension stack are
// not included, nor any redundant clauses.
//
// The 'min_max_var' parameter gives a lower bound on the number ''
// of variables used in the DIMACS 'p cnf ...' header.
//
// Returns zero if successful and otherwise an error message.
//
// require (VALID)
// ensure (VALID)
//
const char *write_dimacs (const char *path, int min_max_var = 0);
// The extension stack for reconstruction a solution can be written too.
//
const char *write_extension (const char *path);
// Print build configuration to a file with prefix 'c '. If the file
// is '' or '' then terminal color codes might be used.
//
static void build (FILE *file, const char *prefix = "c ");
private:
//==== start of state ====================================================
// The solver is in the state ADDING if either the current clause or the
// constraint (or both) is not yet terminated.
bool adding_clause;
bool adding_constraint;
State _state; // API states as discussed above.
/*----------------------------------------------------------------------*/
// The 'Solver' class is a 'facade' object for 'External'. It exposes the
// public API of 'External' but hides everything else (except for the some
// private functions). It is supposed to make it easier to understand the
// API and use the solver through the API.
// This approach has the benefit of decoupling this header file from all
// internal data structures, which is particularly useful if the rest of
// the source is not available. For instance if only a CaDiCaL library is
// installed in a system, then only this header file has to be installed
// too, and still allows to compile and link against the library.
/*----------------------------------------------------------------------*/
// More precisely the CaDiCaL code is split into three layers:
//
// Solver: facade object providing the actual API of the solver
// External: communication layer between 'Solver' and 'Internal'
// Internal: the actual solver code
//
// The 'External' and 'Internal' layers are declared and implemented in
// the corresponding '{external,internal}.{hpp,cpp}' files (as expected),
// while the 'Solver' facade class is defined in 'cadical.hpp' (here) but
// implemented in 'solver.cpp'. The reason for this naming mismatch is,
// that we want to use 'cadical.hpp' for the library header (this header
// file) and call the binary of the stand alone SAT also 'cadical', which
// is more naturally implemented in 'cadical.cpp'.
//
// Separating 'External' from 'Internal' also allows us to map external
// literals to internal literals, which is useful with many fixed or
// eliminated variables (during 'compact' the internal variable range is
// reduced and external variables are remapped). Such an approach is also
// necessary, if we want to use extended resolution in the future (such as
// bounded variable addition).
//
Internal *internal; // Hidden internal solver.
External *external; // Hidden API to internal solver mapping.
#ifndef NTRACING
// The API calls to the solver can be traced by setting the environment
// variable 'CADICAL_API_TRACE' to point to the path of a file to which
// API calls are written. The same format is used which 'mobical' can
// read, execute and also shrink through delta debugging.
//
// The environment variable is read in the constructor and the trace is
// opened for writing and then closed again in the destructor.
//
// Alternatively one case use 'trace_api_calls'. Both
//
bool close_trace_api_file; // Close file if owned by solver it.
FILE *trace_api_file; // Also acts as flag that we are tracing.
static bool tracing_api_through_environment;
//===== end of state ====================================================
void trace_api_call (const char *) const;
void trace_api_call (const char *, int) const;
void trace_api_call (const char *, const char *) const;
void trace_api_call (const char *, const char *, int) const;
#endif
void transition_to_unknown_state ();
//------------------------------------------------------------------------
// Used in the stand alone solver application 'App' and the model based
// tester 'Mobical'. So only these two classes need direct access to the
// otherwise more application specific functions listed here together with
// the internal DIMACS parser.
friend class App;
friend class Mobical;
friend class Parser;
// Read solution in competition format for debugging and testing.
//
// require (VALID)
// ensure (VALID)
//
const char *read_solution (const char *path);
// Cross-compilation with 'MinGW' needs some work-around for 'printf'
// style printing of 64-bit numbers including warning messages. The
// followings lines are copies of similar code in 'inttypes.hpp' but we
// want to keep the 'cadical.hpp' header file stand-alone.
#ifndef PRINTF_FORMAT
#ifdef __MINGW32__
#define __USE_MINGW_ANSI_STDIO 1
#define PRINTF_FORMAT __MINGW_PRINTF_FORMAT
#else
#define PRINTF_FORMAT printf
#endif
#endif
// This gives warning messages for wrong 'printf' style format string
// usage. Apparently (on 'gcc 9' at least) the first argument is 'this'
// here.
//
// TODO: support for other compilers (beside 'gcc' and 'clang').
#define CADICAL_ATTRIBUTE_FORMAT(FORMAT_POSITION, \
VARIADIC_ARGUMENT_POSITION) \
__attribute__ ((format (PRINTF_FORMAT, FORMAT_POSITION, \
VARIADIC_ARGUMENT_POSITION)))
// Messages in a common style.
//
// require (VALID | DELETING)
// ensure (VALID | DELETING)
//
void section (const char *); // print section header
void message (const char *, ...) // ordinary message
CADICAL_ATTRIBUTE_FORMAT (2, 3);
void message (); // empty line - only prefix
void error (const char *, ...) // produce error message
CADICAL_ATTRIBUTE_FORMAT (2, 3);
// Explicit verbose level ('section' and 'message' use '0').
//
// require (VALID | DELETING)
// ensure (VALID | DELETING)
//
void verbose (int level, const char *, ...)
CADICAL_ATTRIBUTE_FORMAT (3, 4);
// Factoring out common code to both 'read_dimacs' functions above.
//
// require (VALID)
// ensure (VALID)
//
const char *read_dimacs (File *, int &, int strict, bool *incremental = 0,
std::vector * = 0);
// Factored out common code for 'solve', 'simplify' and 'lookahead'.
//
int call_external_solve_and_check_results (bool preprocess_only);
//------------------------------------------------------------------------
// Print DIMACS file to '' for debugging and testing purposes,
// including derived units and assumptions. Since it will print in terms
// of internal literals it is otherwise not really useful. To write a
// DIMACS formula in terms of external variables use 'write_dimacs'.
//
// require (!INITIALIZING)
// ensure (!INITIALIZING)
//
void dump_cnf ();
friend struct DumpCall; // Mobical calls 'dump_cnf' in 'DumpCall::execute'
/*----------------------------------------------------------------------*/
// Used in mobical to test external propagation internally.
// These functions should not be called for any other purposes.
//
ExternalPropagator *get_propagator ();
bool observed (int lit);
bool is_witness (int lit);
friend struct LemmaCall;
friend struct ObserveCall;
friend struct DisconnectCall;
friend class MockPropagator;
};
/*========================================================================*/
// Connected terminators are checked for termination regularly. If the
// 'terminate' function of the terminator returns true the solver is
// terminated synchronously as soon it calls this function.
class Terminator {
public:
virtual ~Terminator () {}
virtual bool terminate () = 0;
};
// Connected learners which can be used to export learned clauses.
// The 'learning' can check the size of the learn clause and only if it
// returns true then the individual literals of the learned clause are given
// to the learn through 'learn' one by one terminated by a zero literal.
class Learner {
public:
virtual ~Learner () {}
virtual bool learning (int size) = 0;
virtual void learn (int lit) = 0;
};
/*------------------------------------------------------------------------*/
// Allows to connect an external propagator to propagate values to variables
// with an external clause as a reason or to learn new clauses during the
// CDCL loop (without restart).
class ExternalPropagator {
public:
// This flag is currently checked only when the propagator is connected.
bool is_lazy = false; // lazy propagator only checks complete assignments
virtual ~ExternalPropagator () {}
// Notify the propagator about assignments to observed variables.
// The notification is not necessarily eager. It usually happens before
// the call of propagator callbacks and when a driving clause is leading
// to an assignment.
//
virtual void notify_assignment (int lit, bool is_fixed) = 0;
virtual void notify_new_decision_level () = 0;
virtual void notify_backtrack (size_t new_level) = 0;
// Check by the external propagator the found complete solution (after
// solution reconstruction). If it returns false, the propagator must
// provide an external clause during the next callback.
//
virtual bool cb_check_found_model (const std::vector &model) = 0;
// Ask the external propagator for the next decision literal. If it
// returns 0, the solver makes its own choice.
//
virtual int cb_decide () { return 0; };
// Ask the external propagator if there is an external propagation to make
// under the current assignment. It returns either a literal to be
// propagated or 0, indicating that there is no external propagation under
// the current assignment.
//
virtual int cb_propagate () { return 0; };
// Ask the external propagator for the reason clause of a previous
// external propagation step (done by cb_propagate). The clause must be
// added literal-by-literal closed with a 0. Further, the clause must
// contain the propagated literal.
//
virtual int cb_add_reason_clause_lit (int propagated_lit) {
(void) propagated_lit;
return 0;
};
// The following two functions are used to add external clauses to the
// solver during the CDCL loop. The external clause is added
// literal-by-literal and learned by the solver as an irredundant
// (original) input clause. The clause can be arbitrary, but if it is
// root-satisfied or tautology, the solver will ignore it without learning
// it. Root-falsified literals are eagerly removed from the clause.
// Falsified clauses trigger conflict analysis, propagating clauses
// trigger propagation. In case chrono is 0, the solver backtracks to
// propagate the new literal on the right decision level, otherwise it
// potentially will be an out-of-order assignment on the current level.
// Unit clauses always (unless root-satisfied, see above) trigger
// backtracking (independently from the value of the chrono option and
// independently from being falsified or satisfied or unassigned) to level
// 0. Empty clause (or root falsified clause, see above) makes the problem
// unsat and stops the search immediately. A literal 0 must close the
// clause.
//
// The external propagator indicates that there is a clause to add.
//
virtual bool cb_has_external_clause () = 0;
// The actual function called to add the external clause.
//
virtual int cb_add_external_clause_lit () = 0;
};
/*------------------------------------------------------------------------*/
// Allows to traverse all remaining irredundant clauses. Satisfied and
// eliminated clauses are not included, nor any derived units unless such
// a unit literal is frozen. Falsified literals are skipped. If the solver
// is inconsistent only the empty clause is traversed.
//
// If 'clause' returns false traversal aborts early.
class ClauseIterator {
public:
virtual ~ClauseIterator () {}
virtual bool clause (const std::vector &) = 0;
};
/*------------------------------------------------------------------------*/
// Allows to traverse all clauses on the extension stack together with their
// witness cubes. If the solver is inconsistent, i.e., an empty clause is
// found and the formula is unsatisfiable, then nothing is traversed.
//
// The clauses traversed in 'traverse_clauses' together with the clauses on
// the extension stack are logically equivalent to the original clauses.
// See our SAT'19 paper for more details.
//
// The witness literals can be used to extend and fix an assignment on the
// remaining clauses to satisfy the clauses on the extension stack too.
//
// All derived units of non-frozen variables are included too.
//
// If 'witness' returns false traversal aborts early.
class WitnessIterator {
public:
virtual ~WitnessIterator () {}
virtual bool witness (const std::vector &clause,
const std::vector &witness) = 0;
};
/*------------------------------------------------------------------------*/
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/ccadical.cpp 0000664 0000000 0000000 00000010702 14501267155 0016707 0 ustar 00root root 0000000 0000000 #include "cadical.hpp"
#include
#include
namespace CaDiCaL {
struct Wrapper : Learner, Terminator {
Solver *solver;
struct {
void *state;
int (*function) (void *);
} terminator;
struct {
void *state;
int max_length;
int *begin_clause, *end_clause, *capacity_clause;
void (*function) (void *, int *);
} learner;
bool terminate () {
if (!terminator.function)
return false;
return terminator.function (terminator.state);
}
bool learning (int size) {
if (!learner.function)
return false;
return size <= learner.max_length;
}
void learn (int lit) {
if (learner.end_clause == learner.capacity_clause) {
size_t count = learner.end_clause - learner.begin_clause;
size_t size = count ? 2 * count : 1;
learner.begin_clause =
(int *) realloc (learner.begin_clause, size * sizeof (int));
learner.end_clause = learner.begin_clause + count;
learner.capacity_clause = learner.begin_clause + size;
}
*learner.end_clause++ = lit;
if (lit)
return;
learner.function (learner.state, learner.begin_clause);
learner.end_clause = learner.begin_clause;
}
Wrapper () : solver (new Solver ()) {
memset (&terminator, 0, sizeof terminator);
memset (&learner, 0, sizeof learner);
}
~Wrapper () {
terminator.function = 0;
if (learner.begin_clause)
free (learner.begin_clause);
delete solver;
}
};
} // namespace CaDiCaL
using namespace CaDiCaL;
extern "C" {
#include "ccadical.h"
const char *ccadical_signature (void) { return Solver::signature (); }
CCaDiCaL *ccadical_init (void) { return (CCaDiCaL *) new Wrapper (); }
void ccadical_release (CCaDiCaL *wrapper) { delete (Wrapper *) wrapper; }
void ccadical_constrain (CCaDiCaL *wrapper, int lit) {
((Wrapper *) wrapper)->solver->constrain (lit);
}
int ccadical_constraint_failed (CCaDiCaL *wrapper) {
return ((Wrapper *) wrapper)->solver->constraint_failed ();
}
void ccadical_set_option (CCaDiCaL *wrapper, const char *name, int val) {
((Wrapper *) wrapper)->solver->set (name, val);
}
void ccadical_limit (CCaDiCaL *wrapper, const char *name, int val) {
((Wrapper *) wrapper)->solver->limit (name, val);
}
int ccadical_get_option (CCaDiCaL *wrapper, const char *name) {
return ((Wrapper *) wrapper)->solver->get (name);
}
void ccadical_add (CCaDiCaL *wrapper, int lit) {
((Wrapper *) wrapper)->solver->add (lit);
}
void ccadical_assume (CCaDiCaL *wrapper, int lit) {
((Wrapper *) wrapper)->solver->assume (lit);
}
int ccadical_solve (CCaDiCaL *wrapper) {
return ((Wrapper *) wrapper)->solver->solve ();
}
int ccadical_simplify (CCaDiCaL *wrapper) {
return ((Wrapper *) wrapper)->solver->simplify ();
}
int ccadical_val (CCaDiCaL *wrapper, int lit) {
return ((Wrapper *) wrapper)->solver->val (lit);
}
int ccadical_failed (CCaDiCaL *wrapper, int lit) {
return ((Wrapper *) wrapper)->solver->failed (lit);
}
void ccadical_print_statistics (CCaDiCaL *wrapper) {
((Wrapper *) wrapper)->solver->statistics ();
}
void ccadical_terminate (CCaDiCaL *wrapper) {
((Wrapper *) wrapper)->solver->terminate ();
}
int64_t ccadical_active (CCaDiCaL *wrapper) {
return ((Wrapper *) wrapper)->solver->active ();
}
int64_t ccadical_irredundant (CCaDiCaL *wrapper) {
return ((Wrapper *) wrapper)->solver->irredundant ();
}
int ccadical_fixed (CCaDiCaL *wrapper, int lit) {
return ((Wrapper *) wrapper)->solver->fixed (lit);
}
void ccadical_set_terminate (CCaDiCaL *ptr, void *state,
int (*terminate) (void *)) {
Wrapper *wrapper = (Wrapper *) ptr;
wrapper->terminator.state = state;
wrapper->terminator.function = terminate;
if (terminate)
wrapper->solver->connect_terminator (wrapper);
else
wrapper->solver->disconnect_terminator ();
}
void ccadical_set_learn (CCaDiCaL *ptr, void *state, int max_length,
void (*learn) (void *state, int *clause)) {
Wrapper *wrapper = (Wrapper *) ptr;
wrapper->learner.state = state;
wrapper->learner.max_length = max_length;
wrapper->learner.function = learn;
if (learn)
wrapper->solver->connect_learner (wrapper);
else
wrapper->solver->disconnect_learner ();
}
void ccadical_freeze (CCaDiCaL *ptr, int lit) {
((Wrapper *) ptr)->solver->freeze (lit);
}
void ccadical_melt (CCaDiCaL *ptr, int lit) {
((Wrapper *) ptr)->solver->melt (lit);
}
int ccadical_frozen (CCaDiCaL *ptr, int lit) {
return ((Wrapper *) ptr)->solver->frozen (lit);
}
}
cadical-rel-1.7.4/src/ccadical.h 0000664 0000000 0000000 00000004147 14501267155 0016362 0 ustar 00root root 0000000 0000000 #ifndef _ccadical_h_INCLUDED
#define _ccadical_h_INCLUDED
/*------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/*------------------------------------------------------------------------*/
#include
// C wrapper for CaDiCaL's C++ API following IPASIR.
typedef struct CCaDiCaL CCaDiCaL;
const char *ccadical_signature (void);
CCaDiCaL *ccadical_init (void);
void ccadical_release (CCaDiCaL *);
void ccadical_add (CCaDiCaL *, int lit);
void ccadical_assume (CCaDiCaL *, int lit);
int ccadical_solve (CCaDiCaL *);
int ccadical_val (CCaDiCaL *, int lit);
int ccadical_failed (CCaDiCaL *, int lit);
void ccadical_set_terminate (CCaDiCaL *, void *state,
int (*terminate) (void *state));
void ccadical_set_learn (CCaDiCaL *, void *state, int max_length,
void (*learn) (void *state, int *clause));
/*------------------------------------------------------------------------*/
// Non-IPASIR conformant 'C' functions.
void ccadical_constrain (CCaDiCaL *, int lit);
int ccadical_constraint_failed (CCaDiCaL *);
void ccadical_set_option (CCaDiCaL *, const char *name, int val);
void ccadical_limit (CCaDiCaL *, const char *name, int limit);
int ccadical_get_option (CCaDiCaL *, const char *name);
void ccadical_print_statistics (CCaDiCaL *);
int64_t ccadical_active (CCaDiCaL *);
int64_t ccadical_irredundant (CCaDiCaL *);
int ccadical_fixed (CCaDiCaL *, int lit);
void ccadical_terminate (CCaDiCaL *);
void ccadical_freeze (CCaDiCaL *, int lit);
int ccadical_frozen (CCaDiCaL *, int lit);
void ccadical_melt (CCaDiCaL *, int lit);
int ccadical_simplify (CCaDiCaL *);
/*------------------------------------------------------------------------*/
// Support legacy names used before moving to more IPASIR conforming names.
#define ccadical_reset ccadical_release
#define ccadical_sat ccadical_solve
#define ccadical_deref ccadical_val
/*------------------------------------------------------------------------*/
#ifdef __cplusplus
}
#endif
/*------------------------------------------------------------------------*/
#endif
cadical-rel-1.7.4/src/checker.cpp 0000664 0000000 0000000 00000037274 14501267155 0016605 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
inline unsigned Checker::l2u (int lit) {
assert (lit);
assert (lit != INT_MIN);
unsigned res = 2 * (abs (lit) - 1);
if (lit < 0)
res++;
return res;
}
inline signed char Checker::val (int lit) {
assert (lit);
assert (lit != INT_MIN);
assert (abs (lit) < size_vars);
assert (vals[lit] == -vals[-lit]);
return vals[lit];
}
signed char &Checker::mark (int lit) {
const unsigned u = l2u (lit);
assert (u < marks.size ());
return marks[u];
}
inline CheckerWatcher &Checker::watcher (int lit) {
const unsigned u = l2u (lit);
assert (u < watchers.size ());
return watchers[u];
}
/*------------------------------------------------------------------------*/
CheckerClause *Checker::new_clause () {
const size_t size = simplified.size ();
assert (size > 1), assert (size <= UINT_MAX);
const size_t bytes = sizeof (CheckerClause) + (size - 2) * sizeof (int);
CheckerClause *res = (CheckerClause *) new char[bytes];
res->next = 0;
res->hash = last_hash;
res->size = size;
int *literals = res->literals, *p = literals;
for (const auto &lit : simplified)
*p++ = lit;
num_clauses++;
// First two literals are used as watches and should not be false.
//
for (unsigned i = 0; i < 2; i++) {
int lit = literals[i];
if (!val (lit))
continue;
for (unsigned j = i + 1; j < size; j++) {
int other = literals[j];
if (val (other))
continue;
swap (literals[i], literals[j]);
break;
}
}
assert (!val (literals[0]));
assert (!val (literals[1]));
watcher (literals[0]).push_back (CheckerWatch (literals[1], res));
watcher (literals[1]).push_back (CheckerWatch (literals[0], res));
return res;
}
void Checker::delete_clause (CheckerClause *c) {
if (c->size) {
assert (c->size > 1);
assert (num_clauses);
num_clauses--;
} else {
assert (num_garbage);
num_garbage--;
}
delete[](char *) c;
}
void Checker::enlarge_clauses () {
assert (num_clauses == size_clauses);
const uint64_t new_size_clauses = size_clauses ? 2 * size_clauses : 1;
LOG ("CHECKER enlarging clauses of checker from %" PRIu64 " to %" PRIu64,
(uint64_t) size_clauses, (uint64_t) new_size_clauses);
CheckerClause **new_clauses;
new_clauses = new CheckerClause *[new_size_clauses];
clear_n (new_clauses, new_size_clauses);
for (uint64_t i = 0; i < size_clauses; i++) {
for (CheckerClause *c = clauses[i], *next; c; c = next) {
next = c->next;
const uint64_t h = reduce_hash (c->hash, new_size_clauses);
c->next = new_clauses[h];
new_clauses[h] = c;
}
}
delete[] clauses;
clauses = new_clauses;
size_clauses = new_size_clauses;
}
bool Checker::clause_satisfied (CheckerClause *c) {
for (unsigned i = 0; i < c->size; i++)
if (val (c->literals[i]) > 0)
return true;
return false;
}
// The main reason why we have an explicit garbage collection phase is that
// removing clauses from watcher lists eagerly might lead to an accumulated
// quadratic algorithm. Thus we delay removing garbage clauses from watcher
// lists until garbage collection (even though we remove garbage clauses on
// the fly during propagation too). We also remove satisfied clauses.
//
void Checker::collect_garbage_clauses () {
stats.collections++;
for (size_t i = 0; i < size_clauses; i++) {
CheckerClause **p = clauses + i, *c;
while ((c = *p)) {
if (clause_satisfied (c)) {
c->size = 0; // mark as garbage
*p = c->next;
c->next = garbage;
garbage = c;
num_garbage++;
assert (num_clauses);
num_clauses--;
} else
p = &c->next;
}
}
LOG ("CHECKER collecting %" PRIu64 " garbage clauses %.0f%%", num_garbage,
percent (num_garbage, num_clauses));
for (int lit = -size_vars + 1; lit < size_vars; lit++) {
if (!lit)
continue;
CheckerWatcher &ws = watcher (lit);
const auto end = ws.end ();
auto j = ws.begin (), i = j;
for (; i != end; i++) {
CheckerWatch &w = *i;
if (w.clause->size)
*j++ = w;
}
if (j == ws.end ())
continue;
if (j == ws.begin ())
erase_vector (ws);
else
ws.resize (j - ws.begin ());
}
for (CheckerClause *c = garbage, *next; c; c = next)
next = c->next, delete_clause (c);
assert (!num_garbage);
garbage = 0;
}
/*------------------------------------------------------------------------*/
Checker::Checker (Internal *i)
: internal (i), size_vars (0), vals (0), inconsistent (false),
num_clauses (0), num_garbage (0), size_clauses (0), clauses (0),
garbage (0), next_to_propagate (0), last_hash (0) {
LOG ("CHECKER new");
// Initialize random number table for hash function.
//
Random random (42);
for (unsigned n = 0; n < num_nonces; n++) {
uint64_t nonce = random.next ();
if (!(nonce & 1))
nonce++;
assert (nonce), assert (nonce & 1);
nonces[n] = nonce;
}
memset (&stats, 0, sizeof (stats)); // Initialize statistics.
}
Checker::~Checker () {
LOG ("CHECKER delete");
vals -= size_vars;
delete[] vals;
for (size_t i = 0; i < size_clauses; i++)
for (CheckerClause *c = clauses[i], *next; c; c = next)
next = c->next, delete_clause (c);
for (CheckerClause *c = garbage, *next; c; c = next)
next = c->next, delete_clause (c);
delete[] clauses;
}
/*------------------------------------------------------------------------*/
// The simplicity for accessing 'vals' and 'watchers' directly through a
// signed integer literal, comes with the price of slightly more complex
// code in deleting and enlarging the checker data structures.
void Checker::enlarge_vars (int64_t idx) {
assert (0 < idx), assert (idx <= INT_MAX);
int64_t new_size_vars = size_vars ? 2 * size_vars : 2;
while (idx >= new_size_vars)
new_size_vars *= 2;
LOG ("CHECKER enlarging variables of checker from %" PRId64 " to %" PRId64
"",
size_vars, new_size_vars);
signed char *new_vals;
new_vals = new signed char[2 * new_size_vars];
clear_n (new_vals, 2 * new_size_vars);
new_vals += new_size_vars;
if (size_vars) // To make sanitizer happy (without '-O').
memcpy ((void *) (new_vals - size_vars), (void *) (vals - size_vars),
2 * size_vars);
vals -= size_vars;
delete[] vals;
vals = new_vals;
watchers.resize (2 * new_size_vars);
marks.resize (2 * new_size_vars);
assert (idx < new_size_vars);
size_vars = new_size_vars;
}
inline void Checker::import_literal (int lit) {
assert (lit);
assert (lit != INT_MIN);
int idx = abs (lit);
if (idx >= size_vars)
enlarge_vars (idx);
simplified.push_back (lit);
unsimplified.push_back (lit);
}
void Checker::import_clause (const vector &c) {
for (const auto &lit : c)
import_literal (lit);
}
struct lit_smaller {
bool operator() (int a, int b) const {
int c = abs (a), d = abs (b);
if (c < d)
return true;
if (c > d)
return false;
return a < b;
}
};
bool Checker::tautological () {
sort (simplified.begin (), simplified.end (), lit_smaller ());
const auto end = simplified.end ();
auto j = simplified.begin ();
int prev = 0;
for (auto i = j; i != end; i++) {
int lit = *i;
if (lit == prev)
continue; // duplicated literal
if (lit == -prev)
return true; // tautological clause
const signed char tmp = val (lit);
if (tmp > 0)
return true; // satisfied literal and clause
*j++ = prev = lit;
}
simplified.resize (j - simplified.begin ());
return false;
}
/*------------------------------------------------------------------------*/
uint64_t Checker::reduce_hash (uint64_t hash, uint64_t size) {
assert (size > 0);
unsigned shift = 32;
uint64_t res = hash;
while ((((uint64_t) 1) << shift) > size) {
res ^= res >> shift;
shift >>= 1;
}
res &= size - 1;
assert (res < size);
return res;
}
uint64_t Checker::compute_hash () {
unsigned j = last_id % num_nonces;
uint64_t tmp = nonces[j] * last_id;
return last_hash = tmp;
}
CheckerClause **Checker::find () {
stats.searches++;
CheckerClause **res, *c;
const uint64_t hash = compute_hash ();
const unsigned size = simplified.size ();
const uint64_t h = reduce_hash (hash, size_clauses);
for (const auto &lit : simplified)
mark (lit) = true;
for (res = clauses + h; (c = *res); res = &c->next) {
if (c->hash == hash && c->size == size) {
bool found = true;
const int *literals = c->literals;
for (unsigned i = 0; found && i != size; i++)
found = mark (literals[i]);
if (found)
break;
}
stats.collisions++;
}
for (const auto &lit : simplified)
mark (lit) = false;
return res;
}
void Checker::insert () {
stats.insertions++;
if (num_clauses == size_clauses)
enlarge_clauses ();
const uint64_t h = reduce_hash (compute_hash (), size_clauses);
CheckerClause *c = new_clause ();
c->next = clauses[h];
clauses[h] = c;
}
/*------------------------------------------------------------------------*/
inline void Checker::assign (int lit) {
assert (!val (lit));
vals[lit] = 1;
vals[-lit] = -1;
trail.push_back (lit);
}
inline void Checker::assume (int lit) {
signed char tmp = val (lit);
if (tmp > 0)
return;
assert (!tmp);
stats.assumptions++;
assign (lit);
}
void Checker::backtrack (unsigned previously_propagated) {
assert (previously_propagated <= trail.size ());
while (trail.size () > previously_propagated) {
int lit = trail.back ();
assert (val (lit) > 0);
assert (val (-lit) < 0);
vals[lit] = vals[-lit] = 0;
trail.pop_back ();
}
trail.resize (previously_propagated);
next_to_propagate = previously_propagated;
assert (trail.size () == next_to_propagate);
}
/*------------------------------------------------------------------------*/
// This is a standard propagation routine without using blocking literals
// nor without saving the last replacement position.
bool Checker::propagate () {
bool res = true;
while (res && next_to_propagate < trail.size ()) {
int lit = trail[next_to_propagate++];
stats.propagations++;
assert (val (lit) > 0);
assert (abs (lit) < size_vars);
CheckerWatcher &ws = watcher (-lit);
const auto end = ws.end ();
auto j = ws.begin (), i = j;
for (; res && i != end; i++) {
CheckerWatch &w = *j++ = *i;
const int blit = w.blit;
assert (blit != -lit);
const signed char blit_val = val (blit);
if (blit_val > 0)
continue;
const unsigned size = w.size;
if (size == 2) { // not precise since
if (blit_val < 0)
res = false; // clause might be garbage
else
assign (w.blit); // but still sound
} else {
assert (size > 2);
CheckerClause *c = w.clause;
if (!c->size) {
j--;
continue;
} // skip garbage clauses
assert (size == c->size);
int *lits = c->literals;
int other = lits[0] ^ lits[1] ^ (-lit);
assert (other != -lit);
signed char other_val = val (other);
if (other_val > 0) {
j[-1].blit = other;
continue;
}
lits[0] = other, lits[1] = -lit;
unsigned k;
int replacement = 0;
signed char replacement_val = -1;
for (k = 2; k < size; k++)
if ((replacement_val = val (replacement = lits[k])) >= 0)
break;
if (replacement_val >= 0) {
watcher (replacement).push_back (CheckerWatch (-lit, c));
swap (lits[1], lits[k]);
j--;
} else if (!other_val)
assign (other);
else
res = false;
}
}
while (i != end)
*j++ = *i++;
ws.resize (j - ws.begin ());
}
return res;
}
bool Checker::check () {
stats.checks++;
if (inconsistent)
return true;
unsigned previously_propagated = next_to_propagate;
for (const auto &lit : simplified)
assume (-lit);
bool res = !propagate ();
backtrack (previously_propagated);
return res;
}
/*------------------------------------------------------------------------*/
void Checker::add_clause (const char *type) {
#ifndef LOGGING
(void) type;
#endif
int unit = 0;
for (const auto &lit : simplified) {
const signed char tmp = val (lit);
if (tmp < 0)
continue;
assert (!tmp);
if (unit) {
unit = INT_MIN;
break;
}
unit = lit;
}
if (simplified.empty ()) {
LOG ("CHECKER added empty %s clause", type);
inconsistent = true;
}
if (!unit) {
LOG ("CHECKER added and checked falsified %s clause", type);
inconsistent = true;
} else if (unit != INT_MIN) {
LOG ("CHECKER added and checked %s unit clause %d", type, unit);
assign (unit);
stats.units++;
if (!propagate ()) {
LOG ("CHECKER inconsistent after propagating %s unit", type);
inconsistent = true;
}
} else
insert ();
}
void Checker::add_original_clause (uint64_t id, const vector &c) {
if (inconsistent)
return;
START (checking);
LOG (c, "CHECKER addition of original clause");
stats.added++;
stats.original++;
import_clause (c);
last_id = id;
if (tautological ())
LOG ("CHECKER ignoring satisfied original clause");
else
add_clause ("original");
simplified.clear ();
unsimplified.clear ();
STOP (checking);
}
void Checker::add_derived_clause (uint64_t id, const vector &c) {
if (inconsistent)
return;
START (checking);
LOG (c, "CHECKER addition of derived clause");
stats.added++;
stats.derived++;
import_clause (c);
last_id = id;
if (tautological ())
LOG ("CHECKER ignoring satisfied derived clause");
else if (!check ()) {
fatal_message_start ();
fputs ("failed to check derived clause:\n", stderr);
for (const auto &lit : unsimplified)
fprintf (stderr, "%d ", lit);
fputc ('0', stderr);
fatal_message_end ();
} else
add_clause ("derived");
simplified.clear ();
unsimplified.clear ();
STOP (checking);
}
/*------------------------------------------------------------------------*/
void Checker::delete_clause (uint64_t id, const vector &c) {
if (inconsistent)
return;
START (checking);
LOG (c, "CHECKER checking deletion of clause");
stats.deleted++;
import_clause (c);
last_id = id;
if (!tautological ()) {
CheckerClause **p = find (), *d = *p;
if (d) {
assert (d->size > 1);
// Remove from hash table, mark as garbage, connect to garbage list.
num_garbage++;
assert (num_clauses);
num_clauses--;
*p = d->next;
d->next = garbage;
garbage = d;
d->size = 0;
// If there are enough garbage clauses collect them.
if (num_garbage >
0.5 * max ((size_t) size_clauses, (size_t) size_vars))
collect_garbage_clauses ();
} else {
fatal_message_start ();
fputs ("deleted clause not in proof:\n", stderr);
for (const auto &lit : unsimplified)
fprintf (stderr, "%d ", lit);
fputc ('0', stderr);
fatal_message_end ();
}
}
simplified.clear ();
unsimplified.clear ();
STOP (checking);
}
/*------------------------------------------------------------------------*/
void Checker::dump () {
int max_var = 0;
for (uint64_t i = 0; i < size_clauses; i++)
for (CheckerClause *c = clauses[i]; c; c = c->next)
for (unsigned i = 0; i < c->size; i++)
if (abs (c->literals[i]) > max_var)
max_var = abs (c->literals[i]);
printf ("p cnf %d %" PRIu64 "\n", max_var, num_clauses);
for (uint64_t i = 0; i < size_clauses; i++)
for (CheckerClause *c = clauses[i]; c; c = c->next) {
for (unsigned i = 0; i < c->size; i++)
printf ("%d ", c->literals[i]);
printf ("0\n");
}
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/checker.hpp 0000664 0000000 0000000 00000012230 14501267155 0016573 0 ustar 00root root 0000000 0000000 #ifndef _checker_hpp_INCLUDED
#define _checker_hpp_INCLUDED
/*------------------------------------------------------------------------*/
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// This checker implements an online forward DRUP proof checker enabled by
// 'opts.checkproof' (requires 'opts.check' also to be enabled). This is
// useful for model basted testing (and delta-debugging), where we can not
// rely on an external proof checker such as 'drat-trim'. We also do not
// have yet a flow for offline incremental proof checking, while this
// checker here can also be used in an incremental setting.
//
// In essence the checker implements is a simple propagation online SAT
// solver with an additional hash table to find clauses fast for
// 'delete_clause'. It requires its own data structure for clauses
// ('CheckerClause') and watches ('CheckerWatch').
//
// In our experiments the checker slows down overall SAT solving time by a
// factor of 3, which we contribute to its slightly less efficient
// implementation.
/*------------------------------------------------------------------------*/
struct CheckerClause {
CheckerClause *next; // collision chain link for hash table
uint64_t hash; // previously computed full 64-bit hash
unsigned size; // zero if this is a garbage clause
int literals[2]; // otherwise 'literals' of length 'size'
};
struct CheckerWatch {
int blit;
unsigned size;
CheckerClause *clause;
CheckerWatch () {}
CheckerWatch (int b, CheckerClause *c)
: blit (b), size (c->size), clause (c) {}
};
typedef vector CheckerWatcher;
/*------------------------------------------------------------------------*/
class Checker {
Internal *internal;
// Capacity of variable values.
//
int64_t size_vars;
// For the assignment we want to have an as fast access as possible and
// thus we use an array which can also be indexed by negative literals and
// is actually valid in the range [-size_vars+1, ..., size_vars-1].
//
signed char *vals;
// The 'watchers' and 'marks' data structures are not that time critical
// and thus we access them by first mapping a literal to 'unsigned'.
//
static unsigned l2u (int lit);
vector watchers; // watchers of literals
vector marks; // mark bits of literals
signed char &mark (int lit);
CheckerWatcher &watcher (int lit);
bool inconsistent; // found or added empty clause
uint64_t num_clauses; // number of clauses in hash table
uint64_t num_garbage; // number of garbage clauses
uint64_t size_clauses; // size of clause hash table
CheckerClause **clauses; // hash table of clauses
CheckerClause *garbage; // linked list of garbage clauses
vector unsimplified; // original clause for reporting
vector simplified; // clause for sorting
vector trail; // for propagation
unsigned next_to_propagate; // next to propagate on trail
void enlarge_vars (int64_t idx);
void import_literal (int lit);
void import_clause (const vector &);
bool tautological ();
static const unsigned num_nonces = 4;
uint64_t nonces[num_nonces]; // random numbers for hashing
uint64_t last_hash; // last computed hash value of clause
uint64_t last_id;
uint64_t compute_hash (); // compute and save hash value of clause
// Reduce hash value to the actual size.
//
static uint64_t reduce_hash (uint64_t hash, uint64_t size);
void enlarge_clauses (); // enlarge hash table for clauses
void insert (); // insert clause in hash table
CheckerClause **find (); // find clause position in hash table
void add_clause (const char *type);
void collect_garbage_clauses ();
CheckerClause *new_clause ();
void delete_clause (CheckerClause *);
signed char val (int lit); // returns '-1', '0' or '1'
bool clause_satisfied (CheckerClause *);
void assign (int lit); // assign a literal to true
void assume (int lit); // assume a literal
bool propagate (); // propagate and check for conflicts
void backtrack (unsigned); // prepare for next clause
bool check (); // check simplified clause is implied
struct {
int64_t added; // number of added clauses
int64_t original; // number of added original clauses
int64_t derived; // number of added derived clauses
int64_t deleted; // number of deleted clauses
int64_t assumptions; // number of assumed literals
int64_t propagations; // number of propagated literals
int64_t insertions; // number of clauses added to hash table
int64_t collisions; // number of hash collisions in 'find'
int64_t searches; // number of searched clauses in 'find'
int64_t checks; // number of implication checks
int64_t collections; // garbage collections
int64_t units;
} stats;
public:
Checker (Internal *);
~Checker ();
void add_original_clause (uint64_t, const vector &);
void add_derived_clause (uint64_t, const vector &);
void delete_clause (uint64_t, const vector &);
void print_stats ();
void dump (); // for debugging purposes only
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/clause.cpp 0000664 0000000 0000000 00000037061 14501267155 0016447 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// Signed marking or unmarking of a clause or the global 'clause'.
void Internal::mark (Clause *c) {
for (const auto &lit : *c)
mark (lit);
}
void Internal::mark2 (Clause *c) {
for (const auto &lit : *c)
mark2 (lit);
}
void Internal::unmark (Clause *c) {
for (const auto &lit : *c)
unmark (lit);
}
void Internal::mark_clause () {
for (const auto &lit : clause)
mark (lit);
}
void Internal::unmark_clause () {
for (const auto &lit : clause)
unmark (lit);
}
/*------------------------------------------------------------------------*/
// Mark the variables of an irredundant clause to 'have been removed', which
// will trigger these variables to be considered again in the next bounded
// variable elimination phase. This is called from 'mark_garbage' below.
// Note that 'mark_removed (int lit)' will also mark the blocking flag of
// '-lit' to trigger reconsidering blocking clauses on '-lit'.
void Internal::mark_removed (Clause *c, int except) {
LOG (c, "marking removed");
assert (!c->redundant);
for (const auto &lit : *c)
if (lit != except)
mark_removed (lit);
}
// Mark the variables of a (redundant or irredundant) clause to 'have been
// added', which triggers clauses with such a variables, to be considered
// both as a subsumed or subsuming clause in the next subsumption phase.
// This function is called from 'new_clause' below as well as in situations
// where a clause is shrunken (and thus needs to be at least considered
// again to subsume a larger clause). We also use this to tell
// 'ternary' preprocessing reconsider clauses on an added literal as well as
// trying to block clauses on it.
inline void Internal::mark_added (int lit, int size, bool redundant) {
mark_subsume (lit);
if (size == 3)
mark_ternary (lit);
if (!redundant)
mark_block (lit);
}
void Internal::mark_added (Clause *c) {
LOG (c, "marking added");
assert (likely_to_be_kept_clause (c));
for (const auto &lit : *c)
mark_added (lit, c->size, c->redundant);
}
/*------------------------------------------------------------------------*/
Clause *Internal::new_clause (bool red, int glue) {
assert (clause.size () <= (size_t) INT_MAX);
const int size = (int) clause.size ();
assert (size >= 2);
if (glue > size)
glue = size;
// Determine whether this clauses should be kept all the time.
//
bool keep;
if (!red)
keep = true;
else if (glue <= opts.reducetier1glue)
keep = true;
else
keep = false;
size_t bytes = Clause::bytes (size);
Clause *c = (Clause *) new char[bytes];
stats.added.total++;
c->id = ++clause_id;
c->conditioned = false;
c->covered = false;
c->enqueued = false;
c->frozen = false;
c->garbage = false;
c->gate = false;
c->hyper = false;
c->instantiated = false;
c->keep = keep;
c->moved = false;
c->reason = false;
c->redundant = red;
c->transred = false;
c->subsume = false;
c->vivified = false;
c->vivify = false;
c->used = 0;
c->glue = glue;
c->size = size;
c->pos = 2;
for (int i = 0; i < size; i++)
c->literals[i] = clause[i];
// Just checking that we did not mess up our sophisticated memory layout.
// This might be compiler dependent though. Crucial for correctness.
//
assert (c->bytes () == bytes);
stats.current.total++;
stats.added.total++;
if (red) {
stats.current.redundant++;
stats.added.redundant++;
} else {
stats.irrlits += size;
stats.current.irredundant++;
stats.added.irredundant++;
}
clauses.push_back (c);
LOG (c, "new pointer %p", (void *) c);
if (likely_to_be_kept_clause (c))
mark_added (c);
return c;
}
/*------------------------------------------------------------------------*/
void Internal::promote_clause (Clause *c, int new_glue) {
assert (c->redundant);
if (c->keep)
return;
if (c->hyper)
return;
int old_glue = c->glue;
if (new_glue >= old_glue)
return;
if (!c->keep && new_glue <= opts.reducetier1glue) {
LOG (c, "promoting with new glue %d to tier1", new_glue);
stats.promoted1++;
c->keep = true;
} else if (old_glue > opts.reducetier2glue &&
new_glue <= opts.reducetier2glue) {
LOG (c, "promoting with new glue %d to tier2", new_glue);
stats.promoted2++;
c->used = 2;
} else if (c->keep)
LOG (c, "keeping with new glue %d in tier1", new_glue);
else if (old_glue <= opts.reducetier2glue)
LOG (c, "keeping with new glue %d in tier2", new_glue);
else
LOG (c, "keeping with new glue %d in tier3", new_glue);
stats.improvedglue++;
c->glue = new_glue;
}
/*------------------------------------------------------------------------*/
// Shrinking a clause, e.g., removing one or more literals, requires to fix
// the 'pos' field, if it exists and points after the new last literal. We
// also have adjust the global statistics counter of irredundant literals
// for irredundant clauses, and also adjust the glue value of redundant
// clauses if the size becomes smaller than the glue. Also mark the
// literals in the resulting clause as 'added'. The result is the number of
// (aligned) removed bytes, resulting from shrinking the clause.
//
size_t Internal::shrink_clause (Clause *c, int new_size) {
assert (new_size >= 2);
int old_size = c->size;
assert (new_size < old_size);
#ifndef NDEBUG
for (int i = c->size; i < new_size; i++)
c->literals[i] = 0;
#endif
if (c->pos >= new_size)
c->pos = 2;
size_t old_bytes = c->bytes ();
c->size = new_size;
size_t new_bytes = c->bytes ();
size_t res = old_bytes - new_bytes;
if (c->redundant)
promote_clause (c, min (c->size - 1, c->glue));
else {
int delta_size = old_size - new_size;
assert (stats.irrlits >= delta_size);
stats.irrlits -= delta_size;
}
if (likely_to_be_kept_clause (c))
mark_added (c);
return res;
}
// This is the 'raw' deallocation of a clause. If the clause is in the
// arena nothing happens. If the clause is not in the arena its memory is
// reclaimed immediately.
void Internal::deallocate_clause (Clause *c) {
char *p = (char *) c;
if (arena.contains (p))
return;
LOG (c, "deallocate pointer %p", (void *) c);
delete[] p;
}
void Internal::delete_clause (Clause *c) {
LOG (c, "delete pointer %p", (void *) c);
size_t bytes = c->bytes ();
stats.collected += bytes;
if (c->garbage) {
assert (stats.garbage.bytes >= (int64_t) bytes);
stats.garbage.bytes -= bytes;
assert (stats.garbage.clauses > 0);
stats.garbage.clauses--;
assert (stats.garbage.literals >= c->size);
stats.garbage.literals -= c->size;
// See the discussion in 'propagate' on avoiding to eagerly trace binary
// clauses as deleted (produce 'd ...' lines) as soon they are marked
// garbage. We avoid this and only trace them as deleted when they are
// actually deleted here. This allows the solver to propagate binary
// garbage clauses without producing incorrect 'd' lines. The effect
// from the proof perspective is that the deletion of these binary
// clauses occurs later in the proof file.
//
if (proof && c->size == 2)
proof->delete_clause (c);
}
deallocate_clause (c);
}
// We want to eagerly update statistics as soon clauses are marked garbage.
// Otherwise 'report' for instance gives wrong numbers after 'subsume'
// before the next 'reduce'. Thus we factored out marking and accounting
// for garbage clauses.
//
// Eagerly deleting clauses instead is problematic, since references to
// these clauses need to be flushed, which is too costly to do eagerly.
//
// We also update garbage statistics at this point. This helps to
// determine whether the garbage collector should be called during for
// instance bounded variable elimination, which usually generates lots of
// garbage clauses.
//
// In order not to miss any update to these clause statistics we call
// 'check_clause_stats' after garbage collection in debugging mode.
//
void Internal::mark_garbage (Clause *c) {
assert (!c->garbage);
// Delay tracing deletion of binary clauses. See the discussion above in
// 'delete_clause' and also in 'propagate'.
//
if (proof && c->size != 2)
proof->delete_clause (c);
assert (stats.current.total > 0);
stats.current.total--;
size_t bytes = c->bytes ();
if (c->redundant) {
assert (stats.current.redundant > 0);
stats.current.redundant--;
} else {
assert (stats.current.irredundant > 0);
stats.current.irredundant--;
assert (stats.irrlits >= c->size);
stats.irrlits -= c->size;
mark_removed (c);
}
stats.garbage.bytes += bytes;
stats.garbage.clauses++;
stats.garbage.literals += c->size;
c->garbage = true;
c->used = 0;
LOG (c, "marked garbage pointer %p", (void *) c);
}
/*------------------------------------------------------------------------*/
// Almost the same function as 'search_assign' except that we do not pretend
// to learn a new unit clause (which was confusing in log files).
void Internal::assign_original_unit (uint64_t id, int lit) {
assert (!level);
assert (!unsat);
const int idx = vidx (lit);
assert (!vals[idx]);
assert (!flags (idx).eliminated ());
Var &v = var (idx);
v.level = level;
v.trail = (int) trail.size ();
v.reason = 0;
const signed char tmp = sign (lit);
vals[idx] = tmp;
vals[-idx] = -tmp;
assert (val (lit) > 0);
assert (val (-lit) < 0);
trail.push_back (lit);
const unsigned uidx = vlit (lit);
unit_clauses[uidx] = id;
LOG ("original unit assign %d", lit);
mark_fixed (lit);
if (propagate ())
return;
LOG ("propagation of original unit results in conflict");
learn_empty_clause ();
}
// New clause added through the API, e.g., while parsing a DIMACS file.
//
void Internal::add_new_original_clause (uint64_t id) {
if (level)
backtrack ();
LOG (original, "original clause");
bool skip = false;
if (unsat) {
LOG ("skipping clause since formula already inconsistent");
skip = true;
} else {
assert (clause.empty ());
// assert (lrat_chain.empty ());
for (const auto &lit : original) {
int tmp = marked (lit);
if (tmp > 0) {
LOG ("removing duplicated literal %d", lit);
} else if (tmp < 0) {
LOG ("tautological since both %d and %d occur", -lit, lit);
skip = true;
} else {
mark (lit);
tmp = val (lit);
if (tmp < 0) {
LOG ("removing falsified literal %d", lit);
if (opts.lrat && !opts.lratexternal) {
int elit = externalize (lit);
unsigned eidx = (elit > 0) + 2u * (unsigned) abs (elit);
if (!external->ext_units[eidx]) {
uint64_t uid = (unit_clauses[vlit (-lit)]);
assert (uid);
lrat_chain.push_back (uid);
}
}
} else if (tmp > 0) {
LOG ("satisfied since literal %d true", lit);
skip = true;
} else {
clause.push_back (lit);
assert (flags (lit).status != Flags::UNUSED);
}
}
}
for (const auto &lit : original)
unmark (lit);
}
if (skip) {
if (proof) {
if (opts.lrat) {
proof->delete_external_original_clause (id, external->eclause);
} else {
proof->delete_external_original_clause (id, external->eclause);
}
}
} else {
uint64_t new_id = id;
size_t size = clause.size ();
if (original.size () > size) {
new_id = ++clause_id;
if (proof) {
if (opts.lrat && !opts.lratexternal) {
lrat_chain.push_back (id);
LOG (lrat_chain, "proof chain: ");
proof->add_derived_clause (new_id, clause, lrat_chain);
} else
proof->add_derived_clause (new_id, clause);
if (opts.lrat)
proof->delete_external_original_clause (id, external->eclause);
else
proof->delete_external_original_clause (id, external->eclause);
}
}
lrat_chain.clear ();
if (!size) {
if (!unsat) {
if (!original.size ())
VERBOSE (1, "found empty original clause");
else
MSG ("found falsified original clause");
unsat = true;
conflict_id = new_id;
}
} else if (size == 1) {
assign_original_unit (new_id, clause[0]);
} else {
Clause *c = new_clause (false);
c->id = new_id;
clause_id--;
watch_clause (c);
}
if (original.size () > size) {
external->check_learned_clause ();
}
}
clause.clear ();
lrat_chain.clear ();
}
// Add learned new clause during conflict analysis and watch it. Requires
// that the clause is at least of size 2, and the first two literals
// are assigned at the highest decision level.
//
Clause *Internal::new_learned_redundant_clause (int glue) {
assert (clause.size () > 1);
#ifndef NDEBUG
for (size_t i = 2; i < clause.size (); i++)
assert (var (clause[0]).level >= var (clause[i]).level),
assert (var (clause[1]).level >= var (clause[i]).level);
#endif
external->check_learned_clause ();
Clause *res = new_clause (true, glue);
if (proof) {
if (opts.lrat && !opts.lratexternal) {
LOG (lrat_chain, "new learned redundant clause with proof chain: ");
proof->add_derived_clause (res, lrat_chain);
} else
proof->add_derived_clause (res);
}
assert (watching ());
watch_clause (res);
return res;
}
// Add hyper binary resolved clause during 'probing'.
//
Clause *Internal::new_hyper_binary_resolved_clause (bool red, int glue) {
external->check_learned_clause ();
Clause *res = new_clause (red, glue);
if (proof) {
if (opts.lrat && !opts.lratexternal) {
LOG (lrat_chain,
"new hyper binary resolved clause with proof chain: ");
proof->add_derived_clause (res, lrat_chain);
} else
proof->add_derived_clause (res);
}
assert (watching ());
watch_clause (res);
return res;
}
// Add hyper ternary resolved clause during 'ternary'.
//
Clause *Internal::new_hyper_ternary_resolved_clause (bool red) {
external->check_learned_clause ();
size_t size = clause.size ();
Clause *res = new_clause (red, size);
if (proof) {
if (opts.lrat && !opts.lratexternal) {
LOG (lrat_chain,
"new hyper ternary resolved clause with proof chain: ");
proof->add_derived_clause (res, lrat_chain);
} else
proof->add_derived_clause (res);
}
assert (!watching ());
return res;
}
// Add a new clause with same glue and redundancy as 'orig' but literals are
// assumed to be in 'clause' in 'decompose' and 'vivify'.
//
Clause *Internal::new_clause_as (const Clause *orig) {
external->check_learned_clause ();
const int new_glue = orig->glue;
Clause *res = new_clause (orig->redundant, new_glue);
assert (!orig->redundant || !orig->keep || res->keep);
if (proof) {
if (opts.lrat && !opts.lratexternal) {
LOG (lrat_chain,
"new clause as %" PRIu64 " with proof chain: ", orig->id);
proof->add_derived_clause (res, lrat_chain);
} else
proof->add_derived_clause (res);
}
assert (watching ());
watch_clause (res);
return res;
}
// Add resolved clause during resolution, e.g., bounded variable
// elimination, but do not connect its occurrences here.
//
Clause *Internal::new_resolved_irredundant_clause () {
external->check_learned_clause ();
Clause *res = new_clause (false);
if (proof) {
if (opts.lrat && !opts.lratexternal) {
LOG (lrat_chain,
"new resolved irredundant clause with proof chain: ");
proof->add_derived_clause (res, lrat_chain);
} else
proof->add_derived_clause (res);
}
assert (!watching ());
return res;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/clause.hpp 0000664 0000000 0000000 00000015345 14501267155 0016455 0 ustar 00root root 0000000 0000000 #ifndef _clause_hpp_INCLUDED
#define _clause_hpp_INCLUDED
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
typedef int *literal_iterator;
typedef const int *const_literal_iterator;
/*------------------------------------------------------------------------*/
// The 'Clause' data structure is very important. There are usually many
// clauses and accessing them is a hot-spot. Thus we use common
// optimizations to reduce memory and improve cache usage, even though this
// induces some complexity in understanding the code.
//
// The most important optimization is to 'embed' the actual literals in the
// clause. This requires a variadic size structure and thus strictly is not
// 'C' conform, but supported by all compilers we used. The alternative is
// to store the actual literals somewhere else, which not only needs more
// memory but more importantly also requires another memory access and thus
// is very costly.
struct Clause {
uint64_t id; // Used to create LRAT-style proofs
bool conditioned : 1; // Tried for globally blocked clause elimination.
bool covered : 1; // Already considered for covered clause elimination.
bool enqueued : 1; // Enqueued on backward queue.
bool frozen : 1; // Temporarily frozen (in covered clause elimination).
bool garbage : 1; // can be garbage collected unless it is a 'reason'
bool gate : 1; // Clause part of a gate (function definition).
bool hyper : 1; // redundant hyper binary or ternary resolved
bool instantiated : 1; // tried to instantiate
bool keep : 1; // always keep this clause (if redundant)
bool moved : 1; // moved during garbage collector ('copy' valid)
bool reason : 1; // reason / antecedent clause can not be collected
bool redundant : 1; // aka 'learned' so not 'irredundant' (original)
bool transred : 1; // already checked for transitive reduction
bool subsume : 1; // not checked in last subsumption round
unsigned used : 2; // resolved in conflict analysis since last 'reduce'
bool vivified : 1; // clause already vivified
bool vivify : 1; // clause scheduled to be vivified
// The glucose level ('LBD' or short 'glue') is a heuristic value for the
// expected usefulness of a learned clause, where smaller glue is consider
// more useful. During learning the 'glue' is determined as the number of
// decisions in the learned clause. Thus the glue of a clause is a strict
// upper limit on the smallest number of decisions needed to make it
// propagate. For instance a binary clause will propagate if one of its
// literals is set to false. Similarly a learned clause with glue 1 can
// propagate after one decision, one with glue 2 after 2 decisions etc.
// In some sense the glue is an abstraction of the size of the clause.
//
// See the IJCAI'09 paper by Audemard & Simon for more details. We
// switched back and forth between keeping the glue stored in a clause and
// using it only initially to determine whether it is kept, that is
// survives clause reduction. The latter strategy is not bad but also
// does not allow to use glue values for instance in 'reduce'.
//
// More recently we also update the glue and promote clauses to lower
// level tiers during conflict analysis. The idea of using three tiers is
// also due to Chanseok Oh and thus used in all recent 'Maple...' solvers.
// Tier one are the always kept clauses with low glue at most
// 'opts.reducetier1glue' (default '2'). The second tier contains all
// clauses with glue larger than 'opts.reducetier1glue' but smaller or
// equal than 'opts.reducetier2glue' (default '6'). The third tier
// consists of clauses with glue larger than 'opts.reducetier2glue'.
//
// Clauses in tier one are not deleted in 'reduce'. Clauses in tier
// two require to be unused in two consecutive 'reduce' intervals before
// being collected while for clauses in tier three not being used since
// the last 'reduce' call makes them deletion candidates. Clauses derived
// by hyper binary or ternary resolution (even though small and thus with
// low glue) are always removed if they remain unused during one interval.
// See 'mark_useless_redundant_clauses_as_garbage' in 'reduce.cpp' and
// 'bump_clause' in 'analyze.cpp'.
//
int glue;
int size; // Actual size of 'literals' (at least 2).
int pos; // Position of last watch replacement [Gent'13].
union {
int literals[2]; // Of variadic 'size' (shrunken if strengthened).
Clause *copy; // Only valid if 'moved', then that's where to.
//
// The 'copy' field is only valid for 'moved' clauses in the moving
// garbage collector 'copy_non_garbage_clauses' for keeping clauses
// compactly in a contiguous memory arena. Otherwise, most of
// the time, 'literals' is valid. See 'collect.cpp' for details.
};
literal_iterator begin () { return literals; }
literal_iterator end () { return literals + size; }
const_literal_iterator begin () const { return literals; }
const_literal_iterator end () const { return literals + size; }
static size_t bytes (int size) {
// Memory sanitizer insists that clauses put into consecutive memory in
// the arena are still 8 byte aligned. We could also allocate 8 byte
// aligned memory there. However, assuming the real memory foot print
// of a clause is 8 bytes anyhow, we just allocate 8 byte aligned memory
// all the time (even if allocated outside of the arena).
//
assert (size > 1);
return align ((size - 2) * sizeof (int) + sizeof (Clause), 8);
}
size_t bytes () const { return bytes (size); }
// Check whether this clause is ready to be collected and deleted. The
// 'reason' flag is only there to protect reason clauses in 'reduce',
// which does not backtrack to the root level. If garbage collection is
// triggered from a preprocessor, which backtracks to the root level, then
// 'reason' is false for sure. We want to use the same garbage collection
// code though for both situations and thus hide here this variance.
//
bool collect () const { return !reason && garbage; }
};
struct clause_smaller_size {
bool operator() (const Clause *a, const Clause *b) {
return a->size < b->size;
}
};
/*------------------------------------------------------------------------*/
// Place literals over the same variable close to each other. This would
// allow eager removal of identical literals and detection of tautological
// clauses but is only currently used for better logging (see also
// 'opts.logsort' in 'logging.cpp').
struct clause_lit_less_than {
bool operator() (int a, int b) const {
int s = abs (a), t = abs (b);
return s < t || (s == t && a < b);
}
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/collect.cpp 0000664 0000000 0000000 00000034277 14501267155 0016626 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// Returns the positive number '1' ( > 0) if the given clause is root level
// satisfied or the negative number '-1' ( < 0) if it is not root level
// satisfied but contains a root level falsified literal. Otherwise, if it
// contains neither a satisfied nor falsified literal, then '0' is returned.
int Internal::clause_contains_fixed_literal (Clause *c) {
int satisfied = 0, falsified = 0;
for (const auto &lit : *c) {
const int tmp = fixed (lit);
if (tmp > 0) {
LOG (c, "root level satisfied literal %d in", lit);
satisfied++;
}
if (tmp < 0) {
LOG (c, "root level falsified literal %d in", lit);
falsified++;
}
}
if (satisfied)
return 1;
else if (falsified)
return -1;
else
return 0;
}
// Assume that the clause is not root level satisfied but contains a literal
// set to false (root level falsified literal), so it can be shrunken. The
// clause data is not actually reallocated at this point to avoid dealing
// with issues of special policies for watching binary clauses or whether a
// clause is extended or not. Only its size field is adjusted accordingly
// after flushing out root level falsified literals.
void Internal::remove_falsified_literals (Clause *c) {
const const_literal_iterator end = c->end ();
const_literal_iterator i;
int num_non_false = 0;
for (i = c->begin (); num_non_false < 2 && i != end; i++)
if (fixed (*i) >= 0)
num_non_false++;
if (num_non_false < 2)
return;
if (proof)
proof->flush_clause (c);
literal_iterator j = c->begin ();
for (i = j; i != end; i++) {
const int lit = *j++ = *i, tmp = fixed (lit);
assert (tmp <= 0);
if (tmp >= 0)
continue;
LOG ("flushing %d", lit);
j--;
}
stats.collected += shrink_clause (c, j - c->begin ());
}
// If there are new units (fixed variables) since the last garbage
// collection we go over all clauses, mark satisfied ones as garbage and
// flush falsified literals. Otherwise if no new units have been generated
// since the last garbage collection just skip this step.
void Internal::mark_satisfied_clauses_as_garbage () {
if (last.collect.fixed >= stats.all.fixed)
return;
last.collect.fixed = stats.all.fixed;
LOG ("marking satisfied clauses and removing falsified literals");
for (const auto &c : clauses) {
if (c->garbage)
continue;
const int tmp = clause_contains_fixed_literal (c);
if (tmp > 0)
mark_garbage (c);
else if (tmp < 0)
remove_falsified_literals (c);
}
}
/*------------------------------------------------------------------------*/
// Reason clauses can not be collected.
//
// We protect reasons before and release protection after garbage collection
// (actually within garbage collection).
//
// For 'reduce' we still need to make sure that all clauses which should not
// be removed are marked as such and thus we need to call it before marking
// clauses to be flushed.
void Internal::protect_reasons () {
LOG ("protecting reason clauses of all assigned variables on trail");
assert (!protected_reasons);
#ifdef LOGGING
size_t count = 0;
#endif
for (const auto &lit : trail) {
if (!active (lit))
continue;
assert (val (lit));
Var &v = var (lit);
assert (v.level > 0);
Clause *reason = v.reason;
if (!reason)
continue;
if (reason == external_reason)
continue;
LOG (reason, "protecting assigned %d reason %p", lit, (void *) reason);
assert (!reason->reason);
reason->reason = true;
#ifdef LOGGING
count++;
#endif
}
LOG ("protected %zd reason clauses referenced on trail", count);
protected_reasons = true;
}
/*------------------------------------------------------------------------*/
// After garbage collection we reset the 'reason' flag of the reasons
// of assigned literals on the trail.
void Internal::unprotect_reasons () {
LOG ("unprotecting reasons clauses of all assigned variables on trail");
assert (protected_reasons);
#ifdef LOGGING
size_t count = 0;
#endif
for (const auto &lit : trail) {
if (!active (lit))
continue;
assert (val (lit));
Var &v = var (lit);
assert (v.level > 0);
Clause *reason = v.reason;
if (!reason)
continue;
if (reason == external_reason)
continue;
LOG (reason, "unprotecting assigned %d reason %p", lit,
(void *) reason);
assert (reason->reason);
reason->reason = false;
#ifdef LOGGING
count++;
#endif
}
LOG ("unprotected %zd reason clauses referenced on trail", count);
protected_reasons = false;
}
/*------------------------------------------------------------------------*/
// Update occurrence lists before deleting garbage clauses in the context of
// preprocessing, e.g., during bounded variable elimination 'elim'. The
// result is the number of remaining clauses, which in this context means
// the number of non-garbage clauses.
size_t Internal::flush_occs (int lit) {
Occs &os = occs (lit);
const const_occs_iterator end = os.end ();
occs_iterator j = os.begin ();
const_occs_iterator i;
size_t res = 0;
Clause *c;
for (i = j; i != end; i++) {
c = *i;
if (c->collect ())
continue;
*j++ = c->moved ? c->copy : c;
assert (!c->redundant);
res++;
}
os.resize (j - os.begin ());
shrink_occs (os);
return res;
}
// Update watch lists before deleting garbage clauses in the context of
// 'reduce' where we watch and no occurrence lists. We have to protect
// reason clauses not be collected and thus we have this additional check
// hidden in 'Clause.collect', which for the root level context of
// preprocessing is actually redundant.
inline void Internal::flush_watches (int lit, Watches &saved) {
assert (saved.empty ());
Watches &ws = watches (lit);
const const_watch_iterator end = ws.end ();
watch_iterator j = ws.begin ();
const_watch_iterator i;
for (i = j; i != end; i++) {
Watch w = *i;
Clause *c = w.clause;
if (c->collect ())
continue;
if (c->moved)
c = w.clause = c->copy;
w.size = c->size;
const int new_blit_pos = (c->literals[0] == lit);
assert (c->literals[!new_blit_pos] == lit); /*FW1*/
w.blit = c->literals[new_blit_pos];
if (w.binary ())
*j++ = w;
else
saved.push_back (w);
}
ws.resize (j - ws.begin ());
for (const auto &w : saved)
ws.push_back (w);
saved.clear ();
shrink_vector (ws);
}
void Internal::flush_all_occs_and_watches () {
if (occurring ())
for (auto idx : vars)
flush_occs (idx), flush_occs (-idx);
if (watching ()) {
Watches tmp;
for (auto idx : vars)
flush_watches (idx, tmp), flush_watches (-idx, tmp);
}
}
/*------------------------------------------------------------------------*/
void Internal::update_reason_references () {
LOG ("update assigned reason references");
#ifdef LOGGING
size_t count = 0;
#endif
for (auto &lit : trail) {
if (!active (lit))
continue;
Var &v = var (lit);
Clause *c = v.reason;
if (!c)
continue;
if (c == external_reason)
continue;
LOG (c, "updating assigned %d reason", lit);
assert (c->reason);
assert (c->moved);
Clause *d = c->copy;
v.reason = d;
#ifdef LOGGING
count++;
#endif
}
LOG ("updated %zd assigned reason references", count);
}
/*------------------------------------------------------------------------*/
// This is a simple garbage collector which does not move clauses. It needs
// less space than the arena based clause allocator, but is not as cache
// efficient, since the copying garbage collector can put clauses together
// which are likely accessed after each other.
void Internal::delete_garbage_clauses () {
flush_all_occs_and_watches ();
LOG ("deleting garbage clauses");
#ifndef QUIET
int64_t collected_bytes = 0, collected_clauses = 0;
#endif
const auto end = clauses.end ();
auto j = clauses.begin (), i = j;
while (i != end) {
Clause *c = *j++ = *i++;
if (!c->collect ())
continue;
#ifndef QUIET
collected_bytes += c->bytes ();
collected_clauses++;
#endif
delete_clause (c);
j--;
}
clauses.resize (j - clauses.begin ());
shrink_vector (clauses);
PHASE ("collect", stats.collections,
"collected %" PRId64 " bytes of %" PRId64 " garbage clauses",
collected_bytes, collected_clauses);
}
/*------------------------------------------------------------------------*/
// This is the start of the copying garbage collector using the arena. At
// the core is the following function, which copies a clause to the 'to'
// space of the arena. Be careful if this clause is a reason of an
// assignment. In that case update the reason reference.
//
void Internal::copy_clause (Clause *c) {
LOG (c, "moving");
assert (!c->moved);
char *p = (char *) c;
char *q = arena.copy (p, c->bytes ());
c->copy = (Clause *) q;
c->moved = true;
LOG ("copied clause[%" PRId64 "] from %p to %p", c->id, (void *) c,
(void *) c->copy);
}
// This is the moving garbage collector.
void Internal::copy_non_garbage_clauses () {
size_t collected_clauses = 0, collected_bytes = 0;
size_t moved_clauses = 0, moved_bytes = 0;
// First determine 'moved_bytes' and 'collected_bytes'.
//
for (const auto &c : clauses)
if (!c->collect ())
moved_bytes += c->bytes (), moved_clauses++;
else
collected_bytes += c->bytes (), collected_clauses++;
PHASE ("collect", stats.collections,
"moving %zd bytes %.0f%% of %zd non garbage clauses", moved_bytes,
percent (moved_bytes, collected_bytes + moved_bytes),
moved_clauses);
(void) moved_clauses, (void) collected_clauses, (void) collected_bytes;
// Prepare 'to' space of size 'moved_bytes'.
//
arena.prepare (moved_bytes);
// Keep clauses in arena in the same order.
//
if (opts.arenacompact)
for (const auto &c : clauses)
if (!c->collect () && arena.contains (c))
copy_clause (c);
if (opts.arenatype == 1 || !watching ()) {
// Localize according to current clause order.
// If the option 'opts.arenatype == 1' is set, then this means the
// solver uses the original order of clauses. If there are no watches,
// we can not use the watched based copying policies below. This
// happens if garbage collection is triggered during bounded variable
// elimination.
// Copy clauses according to the order of calling 'copy_clause', which
// in essence just gives a compacting garbage collector, since their
// relative order is kept, and actually already gives the largest
// benefit due to better cache locality.
for (const auto &c : clauses)
if (!c->moved && !c->collect ())
copy_clause (c);
} else if (opts.arenatype == 2) {
// Localize according to (original) variable order.
// This is almost the version used by MiniSAT and descendants.
// Our version uses saved phases too.
for (int sign = -1; sign <= 1; sign += 2)
for (auto idx : vars)
for (const auto &w : watches (sign * likely_phase (idx)))
if (!w.clause->moved && !w.clause->collect ())
copy_clause (w.clause);
} else {
// Localize according to decision queue order.
// This is the default for search. It allocates clauses in the order of
// the decision queue and also uses saved phases. It seems faster than
// the MiniSAT version and thus we keep 'opts.arenatype == 3'.
assert (opts.arenatype == 3);
for (int sign = -1; sign <= 1; sign += 2)
for (int idx = queue.last; idx; idx = link (idx).prev)
for (const auto &w : watches (sign * likely_phase (idx)))
if (!w.clause->moved && !w.clause->collect ())
copy_clause (w.clause);
}
// Do not forget to move clauses which are not watched, which happened in
// a rare situation, and now is only left as defensive code.
//
for (const auto &c : clauses)
if (!c->collect () && !c->moved)
copy_clause (c);
flush_all_occs_and_watches ();
update_reason_references ();
// Replace and flush clause references in 'clauses'.
//
const auto end = clauses.end ();
auto j = clauses.begin (), i = j;
for (; i != end; i++) {
Clause *c = *i;
if (c->collect ())
delete_clause (c);
else
assert (c->moved), *j++ = c->copy, deallocate_clause (c);
}
clauses.resize (j - clauses.begin ());
if (clauses.size () < clauses.capacity () / 2)
shrink_vector (clauses);
if (opts.arenasort)
rsort (clauses.begin (), clauses.end (), pointer_rank ());
// Release 'from' space completely and then swap 'to' with 'from'.
//
arena.swap ();
PHASE ("collect", stats.collections,
"collected %zd bytes %.0f%% of %zd garbage clauses",
collected_bytes,
percent (collected_bytes, collected_bytes + moved_bytes),
collected_clauses);
}
/*------------------------------------------------------------------------*/
// Maintaining clause statistics is complex and error prone but necessary
// for proper scheduling of garbage collection, particularly during bounded
// variable elimination. With this function we can check whether these
// statistics are updated correctly.
void Internal::check_clause_stats () {
#ifndef NDEBUG
int64_t irredundant = 0, redundant = 0, total = 0, irrlits = 0;
for (const auto &c : clauses) {
if (c->garbage)
continue;
if (c->redundant)
redundant++;
else
irredundant++;
if (!c->redundant)
irrlits += c->size;
total++;
}
assert (stats.current.irredundant == irredundant);
assert (stats.current.redundant == redundant);
assert (stats.current.total == total);
assert (stats.irrlits == irrlits);
#endif
}
/*------------------------------------------------------------------------*/
bool Internal::arenaing () { return opts.arena && (stats.collections > 1); }
void Internal::garbage_collection () {
if (unsat)
return;
START (collect);
report ('G', 1);
stats.collections++;
mark_satisfied_clauses_as_garbage ();
if (!protected_reasons)
protect_reasons ();
if (arenaing ())
copy_non_garbage_clauses ();
else
delete_garbage_clauses ();
check_clause_stats ();
check_var_stats ();
unprotect_reasons ();
report ('C', 1);
STOP (collect);
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/compact.cpp 0000664 0000000 0000000 00000037406 14501267155 0016624 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// Compacting removes holes generated by inactive variables (fixed,
// eliminated, substituted or pure) by mapping active variables indices down
// to a contiguous interval of indices.
/*------------------------------------------------------------------------*/
bool Internal::compacting () {
if (level)
return false;
if (!opts.compact)
return false;
if (stats.conflicts < lim.compact)
return false;
int inactive = max_var - active ();
assert (inactive >= 0);
if (!inactive)
return false;
if (inactive < opts.compactmin)
return false;
return inactive >= (1e-3 * opts.compactlim) * max_var;
}
/*------------------------------------------------------------------------*/
struct Mapper {
Internal *internal;
int new_max_var; // New 'max_var' after compacting.
int *table; // Old variable index to new literal map.
int first_fixed; // First fixed variable index.
int map_first_fixed; // Mapped literal of first fixed variable.
signed char first_fixed_val; // Value of first fixed variable.
size_t new_vsize;
/*----------------------------------------------------------------------*/
// We produce a compacting garbage collector like map of old 'src' to
// new 'dst' variables. Inactive variables are just skipped except for
// fixed ones which will be mapped to the first fixed variable (in the
// appropriate phase). This avoids to handle the case 'fixed value'
// separately as it is done in Lingeling, where fixed variables are
// mapped to the internal variable '1'.
//
Mapper (Internal *i)
: internal (i), new_max_var (0), first_fixed (0), map_first_fixed (0),
first_fixed_val (0) {
table = new int[internal->max_var + 1u];
clear_n (table, internal->max_var + 1u);
assert (!internal->level);
for (auto src : internal->vars) {
const Flags &f = internal->flags (src);
if (f.active ())
table[src] = ++new_max_var;
else if (f.fixed () && !first_fixed)
table[first_fixed = src] = map_first_fixed = ++new_max_var;
}
first_fixed_val = first_fixed ? internal->val (first_fixed) : 0;
new_vsize = new_max_var + 1u;
}
~Mapper () { delete[] table; }
/*----------------------------------------------------------------------*/
// Map old variable indices. A result of zero means not mapped.
//
int map_idx (int src) {
assert (0 < src);
assert (src <= internal->max_var);
const int res = table[src];
assert (res <= new_max_var);
return res;
}
/*----------------------------------------------------------------------*/
// The 'map_idx' above is just a look-up into the 'table'. Here we have
// to care about signedness of 'src', and in addition that fixed variables
// have all to be mapped to the first fixed variable 'first_fixed'.
//
int map_lit (int src) {
int res = map_idx (abs (src));
if (!res) {
const signed char tmp = internal->val (src);
if (tmp) {
assert (first_fixed);
res = map_first_fixed;
if (tmp != first_fixed_val)
res = -res;
}
} else if ((src) < 0)
res = -res;
assert (abs (res) <= new_max_var);
return res;
}
/*----------------------------------------------------------------------*/
// Map positive variable indices in vector.
//
template void map_vector (vector &v) {
for (auto src : internal->vars) {
const int dst = map_idx (src);
if (!dst)
continue;
assert (0 < dst);
assert (dst <= src);
v[dst] = v[src];
}
v.resize (new_vsize);
shrink_vector (v);
}
/*----------------------------------------------------------------------*/
// Map positive and negative variable indices in two-sided vector.
//
template void map2_vector (vector &v) {
for (auto src : internal->vars) {
const int dst = map_idx (src);
if (!dst)
continue;
assert (0 < dst);
assert (dst <= src);
v[2 * dst] = v[2 * src];
v[2 * dst + 1] = v[2 * src + 1];
}
v.resize (2 * new_vsize);
shrink_vector (v);
}
/*----------------------------------------------------------------------*/
// Map a vector of literals, flush inactive literals, then resize and
// shrink it to fit the new size after flushing.
//
void map_flush_and_shrink_lits (vector &v) {
const auto end = v.end ();
auto j = v.begin (), i = j;
for (; i != end; i++) {
const int src = *i;
int dst = map_idx (abs (src));
assert (abs (dst) <= abs (src));
if (!dst)
continue;
if (src < 0)
dst = -dst;
*j++ = dst;
}
v.resize (j - v.begin ());
shrink_vector (v);
}
};
/*------------------------------------------------------------------------*/
static signed char *ignore_clang_analyze_memory_leak_warning;
void Internal::compact () {
START (compact);
assert (active () < max_var);
stats.compacts++;
assert (!level);
assert (!unsat);
assert (!conflict);
assert (clause.empty ());
assert (levels.empty ());
assert (analyzed.empty ());
assert (minimized.empty ());
assert (control.size () == 1);
assert (propagated == trail.size ());
garbage_collection ();
Mapper mapper (this);
if (mapper.first_fixed)
LOG ("found first fixed %d",
sign (mapper.first_fixed_val) * mapper.first_fixed);
else
LOG ("no variable fixed");
if (!assumptions.empty ()) {
assert (!external->assumptions.empty ());
LOG ("temporarily reset internal assumptions");
reset_assumptions ();
}
const bool is_constraint = !constraint.empty ();
if (is_constraint) {
assert (!external->constraint.empty ());
LOG ("temporarily reset internal constraint");
reset_constraint ();
}
/*======================================================================*/
// In this first part we only map stuff without reallocation / shrinking.
/*======================================================================*/
// Flush the external indices. This has to occur before we map 'vals'.
// Also fixes external units.
//
for (auto eidx : external->vars) {
int src = external->e2i[eidx];
if (!src) {
continue;
}
assert (eidx > 0);
assert (external->ext_units.size () >= (size_t) 2 * eidx + 1);
uint64_t id1 = external->ext_units[2 * eidx];
uint64_t id2 = external->ext_units[2 * eidx + 1];
assert (!id1 || !id2);
if (!id1 && !id2) {
uint64_t new_id1 = unit_clauses[2 * src];
uint64_t new_id2 = unit_clauses[2 * src + 1];
external->ext_units[2 * eidx] = new_id1;
external->ext_units[2 * eidx + 1] = new_id2;
}
int dst = mapper.map_lit (src);
LOG ("compact %" PRId64
" maps external %d to internal %d from internal %d",
stats.compacts, eidx, dst, src);
external->e2i[eidx] = dst;
}
// Delete garbage units. Needs to occur before resizing unit_clauses
//
for (auto src : internal->vars) {
const int dst = mapper.map_idx (src);
assert (dst <= src);
const signed char tmp = internal->val (src);
if (!dst && !tmp) {
unit_clauses[2 * src] = 0;
unit_clauses[2 * src + 1] = 0;
continue;
}
if (!tmp || src == mapper.first_fixed) {
assert (0 < dst);
if (dst == src)
continue;
assert (!unit_clauses[2 * dst] && !unit_clauses[2 * dst + 1]);
unit_clauses[2 * dst] = unit_clauses[2 * src];
unit_clauses[2 * dst + 1] = unit_clauses[2 * src + 1];
unit_clauses[2 * src] = 0;
unit_clauses[2 * src + 1] = 0;
continue;
}
uint64_t id = unit_clauses[2 * src];
int lit = src;
if (!id) {
id = unit_clauses[2 * src + 1];
lit = -lit;
}
unit_clauses[2 * src] = 0;
unit_clauses[2 * src + 1] = 0;
assert (id);
/* Don't delete units...
if (proof && opts.lrat)
proof->delete_unit_clause (id, lit);
*/
}
unit_clauses.resize (2 * mapper.new_vsize);
shrink_vector (unit_clauses);
// Map the literals in all clauses.
//
for (const auto &c : clauses) {
assert (!c->garbage);
for (auto &src : *c) {
assert (!val (src));
int dst;
dst = mapper.map_lit (src);
assert (dst || c->garbage);
src = dst;
}
}
// Map the blocking literals in all watches.
//
if (!wtab.empty ())
for (auto lit : lits)
for (auto &w : watches (lit))
w.blit = mapper.map_lit (w.blit);
// We first flush inactive variables and map the links in the queue. This
// has to be done before we map the actual links data structure 'links'.
{
int prev = 0, mapped_prev = 0, next;
for (int idx = queue.first; idx; idx = next) {
next = links[idx].next;
if (idx == mapper.first_fixed)
continue;
const int dst = mapper.map_idx (idx);
if (!dst)
continue;
assert (active (idx));
if (prev)
links[prev].next = dst;
else
queue.first = dst;
links[idx].prev = mapped_prev;
mapped_prev = dst;
prev = idx;
}
if (prev)
links[prev].next = 0;
else
queue.first = 0;
queue.unassigned = queue.last = mapped_prev;
}
/*======================================================================*/
// In the second part we map, flush and shrink arrays.
/*======================================================================*/
mapper.map_flush_and_shrink_lits (trail);
propagated = trail.size ();
if (mapper.first_fixed) {
assert (trail.size () == 1);
var (mapper.first_fixed).trail = 0; // before mapping 'vtab'
} else
assert (trail.empty ());
if (!probes.empty ())
mapper.map_flush_and_shrink_lits (probes);
/*======================================================================*/
// In the third part we map stuff and also reallocate memory.
/*======================================================================*/
// Now we continue in reverse order of allocated bytes, e.g., see
// 'Internal::enlarge' which reallocates in order of allocated bytes.
mapper.map_vector (ftab);
mapper.map_vector (parents);
mapper.map_vector (marks);
mapper.map_vector (phases.saved);
mapper.map_vector (phases.forced);
mapper.map_vector (phases.target);
mapper.map_vector (phases.best);
mapper.map_vector (phases.prev);
mapper.map_vector (phases.min);
// Special code for 'frozentab'.
//
for (auto src : vars) {
const int dst = abs (mapper.map_lit (src));
if (!dst)
continue;
if (src == dst)
continue;
assert (dst < src);
frozentab[dst] += frozentab[src];
frozentab[src] = 0;
}
frozentab.resize (mapper.new_vsize);
shrink_vector (frozentab);
// Special code for 'relevanttab'.
//
for (auto src : vars) {
const int dst = abs (mapper.map_lit (src));
if (!dst)
continue;
if (src == dst)
continue;
assert (dst < src);
relevanttab[dst] += relevanttab[src];
relevanttab[src] = 0;
}
relevanttab.resize (mapper.new_vsize);
shrink_vector (relevanttab);
/*----------------------------------------------------------------------*/
if (!external->assumptions.empty ()) {
for (const auto &elit : external->assumptions) {
assert (elit);
assert (elit != INT_MIN);
int eidx = abs (elit);
assert (eidx <= external->max_var);
int ilit = external->e2i[eidx];
assert (ilit); // Because we froze all!!!
if (elit < 0)
ilit = -ilit;
assume (ilit);
}
PHASE ("compact", stats.compacts, "reassumed %zd external assumptions",
external->assumptions.size ());
}
// Special case for 'val' as for 'val' we trade branch less code for
// memory and always allocated an [-maxvar,...,maxvar] array.
{
signed char *new_vals = new signed char[2 * mapper.new_vsize];
ignore_clang_analyze_memory_leak_warning = new_vals;
new_vals += mapper.new_vsize;
for (auto src : vars)
new_vals[-mapper.map_idx (src)] = vals[-src];
for (auto src : vars)
new_vals[mapper.map_idx (src)] = vals[src];
new_vals[0] = 0;
vals -= vsize;
delete[] vals;
vals = new_vals;
}
// 'constrain' uses 'val', so this code has to be after remapping that
if (is_constraint) {
assert (!level);
assert (!external->constraint.back ());
for (auto elit : external->constraint) {
assert (elit != INT_MIN);
int eidx = abs (elit);
assert (eidx <= external->max_var);
int ilit = external->e2i[eidx];
assert (!ilit == !elit);
if (elit < 0)
ilit = -ilit;
LOG ("re adding lit external %d internal %d to constraint", elit,
ilit);
constrain (ilit);
}
PHASE ("compact", stats.compacts,
"added %zd external literals to constraint",
external->constraint.size () - 1);
}
mapper.map_vector (i2e);
mapper.map2_vector (ptab);
mapper.map_vector (btab);
mapper.map_vector (gtab);
mapper.map_vector (links);
mapper.map_vector (vtab);
if (!ntab.empty ())
mapper.map2_vector (ntab);
if (!wtab.empty ())
mapper.map2_vector (wtab);
if (!otab.empty ())
mapper.map2_vector (otab);
if (!big.empty ())
mapper.map2_vector (big);
/*======================================================================*/
// In the fourth part we map the binary heap for scores.
/*======================================================================*/
// The simplest way to map a binary heap is to get all elements from the
// heap and reinsert them. This could be slightly improved in terms of
// speed if we add a 'flush (int * map)' function to 'Heap', but that is
// pretty complicated and would require that the 'Heap' knows that mapped
// elements with 'zero' destination should be flushed.
vector saved;
assert (saved.empty ());
if (!scores.empty ()) {
while (!scores.empty ()) {
const int src = scores.front ();
scores.pop_front ();
const int dst = mapper.map_idx (src);
if (!dst)
continue;
if (src == mapper.first_fixed)
continue;
saved.push_back (dst);
}
scores.erase ();
}
mapper.map_vector (stab);
if (!saved.empty ()) {
for (const auto idx : saved)
scores.push_back (idx);
scores.shrink ();
}
/*----------------------------------------------------------------------*/
PHASE ("compact", stats.compacts,
"reducing internal variables from %d to %d", max_var,
mapper.new_max_var);
/*----------------------------------------------------------------------*/
// Need to adjust the target and best assigned counters too.
size_t new_target_assigned = 0, new_best_assigned = 0;
for (auto idx : Range (mapper.new_max_var)) {
if (phases.target[idx])
new_target_assigned++;
if (phases.best[idx])
new_best_assigned++;
}
LOG ("reset target assigned from %zd to %zd", target_assigned,
new_target_assigned);
LOG ("reset best assigned from %zd to %zd", best_assigned,
new_best_assigned);
target_assigned = new_target_assigned;
best_assigned = new_best_assigned;
no_conflict_until = 0;
notified = 0;
INIT_EMA (averages.current.trail.fast, opts.ematrailfast);
INIT_EMA (averages.current.trail.slow, opts.ematrailslow);
/*----------------------------------------------------------------------*/
max_var = mapper.new_max_var;
vsize = mapper.new_vsize;
stats.unused = 0;
stats.inactive = stats.now.fixed = mapper.first_fixed ? 1 : 0;
stats.now.substituted = stats.now.eliminated = stats.now.pure = 0;
check_var_stats ();
int64_t delta = opts.compactint * (stats.compacts + 1);
lim.compact = stats.conflicts + delta;
PHASE ("compact", stats.compacts,
"new compact limit %" PRId64 " after %" PRId64 " conflicts",
lim.compact, delta);
STOP (compact);
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/condition.cpp 0000664 0000000 0000000 00000101445 14501267155 0017157 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// Globally blocked clause elimination (which we call here 'conditioning')
// is described first in the PhD thesis of Benjamin Kiesl from 2019. An
// extended version, which in particular describes the algorithm implemented
// below is in our invited ATVA'19 paper [KieslHeuleBiere-ATVA'19]. This
// accordingly needs witnesses consisting potentially of more than one
// literal. It is the first technique implemented in CaDiCaL with this
// feature (PR clause elimination thus should work in principle too).
// Basically globally blocked clauses are like set blocked clauses, except
// that the witness cube (of literals to be flipped during reconstruction)
// can contain variables which are not in the blocked clause. This
// can simulate some interesting global optimizations like 'headlines' from
// the FAN algorithm for ATPG. The technique was actually motivated to
// simulate this optimization. It turns out that globally blocked clauses
// can be seen as 'conditional autarkies', where in essence the condition
// cube is the negation of the globally blocked redundant clause (it
// needs to contain one autarky literal though) and the autarky part
// represents the witness.
/*------------------------------------------------------------------------*/
// Elimination of globally blocked clauses is first tried in regular
// intervals in terms of the number of conflicts. Then the main heuristics
// is to trigger 'condition' if the decision level is above the current
// moving average of the back jump level.
// TODO We might need to consider less frequent conditioning.
bool Internal::conditioning () {
if (!opts.condition)
return false;
if (!preprocessing && !opts.inprocessing)
return false;
if (preprocessing)
assert (lim.preprocessing);
// Triggered in regular 'opts.conditionint' conflict intervals.
//
if (lim.condition > stats.conflicts)
return false;
if (!level)
return false; // One decision necessary.
if (level <= averages.current.jump)
return false; // Main heuristic.
if (!stats.current.irredundant)
return false;
double remain = active ();
if (!remain)
return false;
double ratio = stats.current.irredundant / remain;
return ratio <= opts.conditionmaxrat;
}
/*------------------------------------------------------------------------*/
// We start with the current assignment and then temporarily unassign
// literals. They are reassigned afterwards. The global state of the CDCL
// solver should not change though. Thus we copied from 'search_unassign'
// in 'backtrack.cpp' what is needed to unassign literals and then from
// 'search_assign' in 'propagate.cpp' what is needed for reassigning
// literals, but restricted the copied code to only updating the actual
// assignment (in 'vals') and not changing anything else.
// We use temporarily unassigning for two purposes. First, if a conditional
// literal does not occur negated in a candidate clause it is unassigned.
// Second, as a minor optimization, we first unassign all root-level
// assigned (fixed) literals, to avoid checking the decision level of
// literals during the procedure.
void Internal::condition_unassign (int lit) {
LOG ("condition unassign %d", lit);
assert (val (lit) > 0);
vals[lit] = vals[-lit] = 0;
}
void Internal::condition_assign (int lit) {
LOG ("condition assign %d", lit);
assert (!val (lit));
vals[lit] = 1;
vals[-lit] = -1;
assert (val (lit) > 0);
assert (val (-lit) < 0);
}
/*------------------------------------------------------------------------*/
// The current partition into conditional part and autarky part during
// refinement is represented through a conditional bit in 'marks'.
inline bool Internal::is_conditional_literal (int lit) const {
return val (lit) > 0 && getbit (lit, 0);
}
inline bool Internal::is_autarky_literal (int lit) const {
return val (lit) > 0 && !getbit (lit, 0);
}
inline void Internal::mark_as_conditional_literal (int lit) {
LOG ("marking %d as conditional literal", lit);
assert (val (lit) > 0);
setbit (lit, 0);
assert (is_conditional_literal (lit));
assert (!is_autarky_literal (lit));
}
inline void Internal::unmark_as_conditional_literal (int lit) {
LOG ("unmarking %d as conditional literal", lit);
assert (is_conditional_literal (lit));
unsetbit (lit, 0);
}
/*------------------------------------------------------------------------*/
// We also need to know the literals which are in the current clause. These
// are just marked (also in 'marks' but with the (signed) upper two bits).
// We need a signed mark here, since we have to distinguish positive and
// negative occurrences of literals in the candidate clause.
inline bool Internal::is_in_candidate_clause (int lit) const {
return marked67 (lit) > 0;
}
inline void Internal::mark_in_candidate_clause (int lit) {
LOG ("marking %d as literal of the candidate clause", lit);
mark67 (lit);
assert (is_in_candidate_clause (lit));
assert (!is_in_candidate_clause (-lit));
}
inline void Internal::unmark_in_candidate_clause (int lit) {
LOG ("unmarking %d as literal of the candidate clause", lit);
assert (is_in_candidate_clause (lit));
unmark67 (lit);
}
/*------------------------------------------------------------------------*/
struct less_conditioned {
bool operator() (Clause *a, Clause *b) {
return !a->conditioned && b->conditioned;
}
};
// This is the function for eliminating globally blocked clauses. It is
// triggered during CDCL search according to 'conditioning' above and uses
// the current assignment as basis to find globally blocked clauses.
long Internal::condition_round (long delta) {
long limit;
#ifndef QUIET
long props = 0;
#endif
if (LONG_MAX - delta < stats.condprops)
limit = LONG_MAX;
else
limit = stats.condprops + delta;
size_t initial_trail_level = trail.size ();
int initial_level = level;
LOG ("initial trail level %zd", initial_trail_level);
protect_reasons ();
#if defined(LOGGING) || !defined(NDEBUG)
int additionally_assigned = 0;
#endif
for (auto idx : vars) {
const signed char tmp = val (idx);
Var &v = var (idx);
if (tmp) {
if (v.level) {
const int lit = tmp < 0 ? -idx : idx;
if (!active (idx)) {
LOG ("temporarily unassigning inactive literal %d", lit);
condition_unassign (lit);
}
if (frozen (idx)) {
LOG ("temporarily unassigning frozen literal %d", lit);
condition_unassign (lit);
}
}
} else if (frozen (idx)) {
LOG ("keeping frozen literal %d unassigned", idx);
} else if (!active (idx)) {
LOG ("keeping inactive literal %d unassigned", idx);
} else { // if (preprocessing) {
if (initial_level == level) {
level++;
LOG ("new condition decision level");
}
const int lit = decide_phase (idx, true);
condition_assign (lit);
v.level = level;
trail.push_back (lit);
#if defined(LOGGING) || !defined(NDEBUG)
additionally_assigned++;
#endif
}
}
LOG ("assigned %d additional literals", additionally_assigned);
// We compute statistics about the size of the assignments.
//
// The initial assignment consists of the non-root-level assigned literals
// split into a conditional and an autarky part. The conditional part
// consists of literals assigned true and occurring negated in a clause
// (touch the clause), which does not contain another literal assigned to
// true. This initial partition is the same for all refinements used in
// checking whether a candidate clause is globally blocked.
//
// For each candidate clause some of the conditional literals have to be
// unassigned, and the autarky is shrunken by turning some of the autarky
// literals into conditional literals (which might get unassigned in a
// later refinement though).
//
// The fix-point of this procedure produces a final assignment, which
// consists of the remaining assigned literals, again split into a
// conditional and an autarky part.
//
struct {
size_t assigned, conditional, autarky;
} initial, remain;
initial.assigned = 0;
for (auto idx : vars) {
const signed char tmp = val (idx);
if (!tmp)
continue;
if (!var (idx).level)
continue;
LOG ("initial assignment %ds", tmp < 0 ? -idx : idx);
initial.assigned++;
}
PHASE ("condition", stats.conditionings, "initial assignment of size %zd",
initial.assigned);
// For each candidate clause we refine the assignment (monotonically),
// by unassigning some conditional literals and turning some autarky
// literals into conditionals.
//
// As the conditional part is usually smaller than the autarky part our
// implementation only explicitly maintains the initial conditional part,
// with conditional bit set to true through 'mark_as_conditional_literal'.
// The autarky part consists of all literals assigned true which do not
// have their conditional bit set to true. Since in both cases the
// literal has to be assigned true, we only need a single bit for both the
// literal as well as its negation (it does not have to be 'signed').
//
vector conditional;
vector candidates; // Gather candidate clauses.
#ifndef QUIET
size_t watched = 0; // Number of watched clauses.
#endif
initial.autarky = initial.assigned; // Initially all are in autarky
initial.conditional = 0; // and none in conditional part.
// Upper bound on the number of watched clauses. In principle one could
// use 'SIZE_MAX' but this is not available by default (yet).
//
const size_t size_max = clauses.size () + 1;
// Initialize additional occurrence lists.
//
init_occs ();
// Number of previously conditioned and unconditioned candidates.
//
size_t conditioned = 0, unconditioned = 0;
// Now go over all (non-garbage) irredundant clauses and check whether
// they are candidates, have to be watched, or whether they force the
// negation of some of their literals to be conditional initially.
//
for (const auto &c : clauses) {
if (c->garbage)
continue; // Can already be ignored.
if (c->redundant)
continue; // Ignore redundant clauses too.
// First determine the following numbers for the candidate clause
// (restricted to non-root-level assignments).
//
int positive = 0; // Number true literals.
int negative = 0; // Number false literals.
int watch = 0; // True Literal to watch.
//
size_t minsize = size_max; // Number of occurrences of 'watch'.
//
// But also ignore root-level satisfied but not yet garbage clauses.
//
bool satisfied = false; // Root level satisfied.
//
for (const_literal_iterator l = c->begin ();
!satisfied && l != c->end (); l++) {
const int lit = *l;
const signed char tmp = val (lit);
if (tmp && !var (lit).level)
satisfied = (tmp > 0);
else if (tmp < 0)
negative++;
else if (tmp > 0) {
const size_t size = occs (lit).size ();
if (size < minsize)
watch = lit, minsize = size;
positive++;
}
}
if (satisfied) { // Ignore root-level satisfied clauses.
mark_garbage (c); // But mark them as garbage already now.
continue; // ... with next clause 'c'.
}
// Candidates are clauses with at least a positive literal in it.
//
if (positive > 0) {
LOG (c, "found %d positive literals in candidate", positive);
candidates.push_back (c);
if (c->conditioned)
conditioned++;
else
unconditioned++;
}
// Only one positive literal in each clauses with also at least one
// negative literal has to be watched in occurrence lists. These
// watched clauses will be checked to contain only negative literals as
// soon such a positive literal is unassigned. If this is the case
// these false literals have to be unassigned and potentially new
// conditional literals have to be determined.
//
// Note that only conditional literals are unassigned. However it does
// not matter that we might also watch autarky literals, because either
// such an autarky literal remains a witness that the clause is
// satisfied as long it remains an autarky literal. Otherwise at one
// point it becomes conditional and is unassigned, but then a
// replacement watch will be searched.
//
if (negative > 0 && positive > 0) {
LOG (c, "found %d negative literals in candidate", negative);
assert (watch);
assert (val (watch) > 0);
Occs &os = occs (watch);
assert (os.size () == minsize);
os.push_back (c);
#ifndef QUIET
watched++;
#endif
LOG (c, "watching %d with %zd occurrences in", watch, minsize);
}
// The initial global conditional part for the current assignment is
// extracted from clauses with only negative literals. It is the same
// for all considered candidate clauses. These negative literals make up
// the global conditional part, are marked here.
//
if (negative > 0 && !positive) {
size_t new_conditionals = 0;
for (const_literal_iterator l = c->begin (); l != c->end (); l++) {
const int lit = *l;
signed char tmp = val (lit);
if (!tmp)
continue;
assert (tmp < 0);
if (!var (lit).level)
continue; // Not unassigned yet!
if (is_conditional_literal (-lit))
continue;
mark_as_conditional_literal (-lit);
conditional.push_back (-lit);
new_conditionals++;
}
if (new_conditionals > 0)
LOG (c, "marked %zu negations of literals as conditional in",
new_conditionals);
initial.conditional += new_conditionals;
assert (initial.autarky >= new_conditionals);
initial.autarky -= new_conditionals;
}
} // End of loop over all clauses to collect candidates etc.
PHASE ("condition", stats.conditionings, "found %zd candidate clauses",
candidates.size ());
PHASE ("condition", stats.conditionings,
"watching %zu literals and clauses", watched);
PHASE ("condition", stats.conditionings,
"initially %zd conditional literals %.0f%%", initial.conditional,
percent (initial.conditional, initial.assigned));
PHASE ("condition", stats.conditionings,
"initially %zd autarky literals %.0f%%", initial.autarky,
percent (initial.autarky, initial.assigned));
#ifdef LOGGING
for (size_t i = 0; i < conditional.size (); i++) {
LOG ("initial conditional %d", conditional[i]);
assert (is_conditional_literal (conditional[i]));
}
for (size_t i = 0; i < trail.size (); i++)
if (is_autarky_literal (trail[i]))
LOG ("initial autarky %d", trail[i]);
#endif
assert (initial.conditional == conditional.size ());
assert (initial.assigned == initial.conditional + initial.autarky);
stats.condassinit += initial.assigned;
stats.condcondinit += initial.conditional;
stats.condautinit += initial.autarky;
stats.condassvars += active ();
// To speed-up and particularly simplify the code we unassign all
// root-level variables temporarily, actually all inactive assigned
// variables. This allows us to avoid tests on whether an assigned
// literal is actually root-level assigned and thus should be ignored (not
// considered to be assigned). For this to work we have to ignore root
// level satisfied clauses as done above. These are neither candidates
// nor have to be watched. Remaining originally root-level assigned
// literals in clauses are only set to false.
//
for (const auto &lit : trail)
if (fixed (lit))
condition_unassign (lit);
// Stack to save temporarily unassigned (conditional) literals.
//
vector unassigned;
// Make sure to focus on clauses not tried before by marking clauses which
// have been checked before using the 'conditioned' bit of clauses. If all
// candidates have their bit set, we have to reset it. Since the
// assignment might be completely different then last time and thus also
// the set of candidates this method does not really exactly lead to a
// round robin scheme of scheduling clauses.
//
// TODO consider computing conditioned and unconditioned over all clauses.
//
assert (conditioned + unconditioned == candidates.size ());
if (conditioned && unconditioned) {
stable_sort (candidates.begin (), candidates.end (),
less_conditioned ());
PHASE ("condition", stats.conditionings,
"focusing on %zd candidates %.0f%% not tried last time",
unconditioned, percent (unconditioned, candidates.size ()));
} else if (conditioned && !unconditioned) {
for (auto const &c : candidates) {
assert (c->conditioned);
c->conditioned = false; // Reset 'conditioned' bit.
}
PHASE ("condition", stats.conditionings,
"all %zd candidates tried before", conditioned);
} else {
assert (!conditioned);
PHASE ("condition", stats.conditionings, "all %zd candidates are fresh",
unconditioned);
}
// TODO prune assignments further!
// And thus might result in less watched clauses.
// So watching should be done here and not earlier.
// Also, see below, we might need to consider the negation of unassigned
// literals in candidate clauses as being watched.
// Now try to block all candidate clauses.
//
long blocked = 0; // Number of Successfully blocked clauses.
//
#ifndef QUIET
size_t untried = candidates.size ();
#endif
for (const auto &c : candidates) {
if (initial.autarky <= 0)
break;
if (c->reason)
continue;
bool terminated_or_limit_hit = true;
if (terminated_asynchronously ())
LOG ("asynchronous termination detected");
else if (stats.condprops >= limit)
LOG ("condition propagation limit %ld hit", limit);
else
terminated_or_limit_hit = false;
if (terminated_or_limit_hit) {
PHASE ("condition", stats.conditionings,
"%zd candidates %.0f%% not tried after %ld propagations",
untried, percent (untried, candidates.size ()), props);
break;
}
#ifndef QUIET
untried--;
#endif
assert (!c->garbage);
assert (!c->redundant);
LOG (c, "candidate");
c->conditioned = 1; // Next time later.
// We watch an autarky literal in the clause, and can stop trying to
// globally block the clause as soon it turns into a conditional
// literal and we can not find another one. If the fix-point assignment
// is reached and we still have an autarky literal left the watched one
// is reported as witness for this clause being globally blocked.
//
int watched_autarky_literal = 0;
// First mark all true literals in the candidate clause and find an
// autarky literal which witnesses that this clause has still a chance
// to be globally blocked.
//
for (const_literal_iterator l = c->begin (); l != c->end (); l++) {
const int lit = *l;
mark_in_candidate_clause (lit);
if (watched_autarky_literal)
continue;
if (!is_autarky_literal (lit))
continue;
watched_autarky_literal = lit;
// TODO assign non-assigned literals to false?
// Which might need to trigger watching additional clauses.
}
if (!watched_autarky_literal) {
LOG ("no initial autarky literal found");
for (const_literal_iterator l = c->begin (); l != c->end (); l++)
unmark_in_candidate_clause (*l);
continue;
}
stats.condcands++; // Only now ...
LOG ("watching first autarky literal %d", watched_autarky_literal);
// Save assignment sizes for statistics, logging and checking.
//
remain = initial;
// Position of next conditional and unassigned literal to process in the
// 'conditional' and the 'unassigned' stack.
//
struct {
size_t conditional, unassigned;
} next = {0, 0};
assert (unassigned.empty ());
assert (conditional.size () == initial.conditional);
while (watched_autarky_literal && stats.condprops < limit &&
next.conditional < conditional.size ()) {
assert (next.unassigned == unassigned.size ());
const int conditional_lit = conditional[next.conditional++];
LOG ("processing next conditional %d", conditional_lit);
assert (is_conditional_literal (conditional_lit));
if (is_in_candidate_clause (-conditional_lit)) {
LOG ("conditional %d negated in candidate clause", conditional_lit);
continue;
}
LOG ("conditional %d does not occur negated in candidate clause",
conditional_lit);
condition_unassign (conditional_lit);
assert (!is_conditional_literal (conditional_lit));
unassigned.push_back (conditional_lit);
assert (remain.assigned > 0);
assert (remain.conditional > 0);
remain.conditional--;
remain.assigned--;
while (watched_autarky_literal && stats.condprops < limit &&
next.unassigned < unassigned.size ()) {
const int unassigned_lit = unassigned[next.unassigned++];
LOG ("processing next unassigned %d", unassigned_lit);
assert (!val (unassigned_lit));
#ifndef QUIET
props++;
#endif
stats.condprops++;
Occs &os = occs (unassigned_lit);
if (os.empty ())
continue;
// Traverse all watched clauses of 'unassigned_lit' and find
// replacement watches or if none is found turn the negation of all
// false autarky literals in that clause into conditional literals.
// If one of those autarky literals is the watched autarky literal
// in the candidate clause, that one has to be updated too.
//
// We expect that this loop is a hot-spot for the procedure and thus
// are more careful about accessing end points for iterating.
//
auto i = os.begin (), j = i;
for (; watched_autarky_literal && j != os.end (); j++) {
Clause *d = *i++ = *j;
int replacement = 0; // New watched literal in 'd'.
int negative = 0; // Negative autarky literals in 'd'.
for (const_literal_iterator l = d->begin (); l != d->end ();
l++) {
const int lit = *l;
const signed char tmp = val (lit);
if (tmp > 0)
replacement = lit;
if (tmp < 0 && is_autarky_literal (-lit))
negative++;
}
if (replacement) {
LOG ("found replacement %d for unassigned %d", replacement,
unassigned_lit);
LOG (d, "unwatching %d in", unassigned_lit);
i--; // Drop watch!
LOG (d, "watching %d in", replacement);
assert (replacement != unassigned_lit);
occs (replacement).push_back (d);
continue; // ... with next watched clause 'd'.
}
LOG ("no replacement found for unassigned %d", unassigned_lit);
// Keep watching 'd' by 'unassigned_lit' if no replacement found.
if (!negative) {
LOG (d, "no negative autarky literals left in");
continue; // ... with next watched clause 'd'.
}
LOG (d, "found %d negative autarky literals in", negative);
for (const_literal_iterator l = d->begin ();
watched_autarky_literal && l != d->end (); l++) {
const int lit = *l;
if (!is_autarky_literal (-lit))
continue;
mark_as_conditional_literal (-lit);
conditional.push_back (-lit);
remain.conditional++;
assert (remain.autarky > 0);
remain.autarky--;
if (-lit != watched_autarky_literal)
continue;
LOG ("need to replace autarky literal %d in candidate", -lit);
replacement = 0;
// TODO save starting point because we only move it forward?
for (const_literal_iterator k = c->begin ();
!replacement && k != c->end (); k++) {
const int other = *k;
if (is_autarky_literal (other))
replacement = other;
}
watched_autarky_literal = replacement;
if (replacement) {
LOG (c, "watching autarky %d instead %d in candidate",
replacement, watched_autarky_literal);
watched_autarky_literal = replacement;
} else {
LOG ("failed to find an autarky replacement");
watched_autarky_literal = 0; // Breaks out of 4 loops!!!!!
}
} // End of loop of turning autarky literals into conditionals.
} // End of loop of all watched clauses of an unassigned literal.
//
// We might abort the occurrence traversal early but already
// removed some watches, thus have to just copy the rest.
//
if (i < j) {
while (j != os.end ())
*i++ = *j++;
LOG ("flushed %zd occurrences of %d", os.end () - i,
unassigned_lit);
os.resize (i - os.begin ());
}
} // End of loop which goes over all unprocessed unassigned literals.
} // End of loop which goes over all unprocessed conditional literals.
// We are still processing the candidate 'c' and now have reached a
// final fix-point assignment partitioned into a conditional and an
// autarky part, or during unassigned literals figured that there is no
// positive autarky literal left in 'c'.
LOG ("remaining assignment of size %zd", remain.assigned);
LOG ("remaining conditional part of size %zd", remain.conditional);
LOG ("remaining autarky part of size %zd", remain.autarky);
//
assert (remain.assigned - remain.conditional == remain.autarky);
//
#if defined(LOGGING) || !defined(NDEBUG)
//
// This is a sanity check, that the size of our implicit representation
// of the autarky part matches our 'remain' counts. We need the same
// code for determining autarky literals as in the loop below which adds
// autarky literals to the extension stack.
//
struct {
size_t assigned, conditional, autarky;
} check;
check.assigned = check.conditional = check.autarky = 0;
for (size_t i = 0; i < trail.size (); i++) {
const int lit = trail[i];
if (val (lit)) {
check.assigned++;
if (is_conditional_literal (lit)) {
LOG ("remaining conditional %d", lit);
assert (!is_autarky_literal (lit));
check.conditional++;
} else {
assert (is_autarky_literal (lit));
LOG ("remaining autarky %d", lit);
check.autarky++;
}
} else {
assert (!is_autarky_literal (lit));
assert (!is_conditional_literal (lit));
}
}
assert (remain.assigned == check.assigned);
assert (remain.conditional == check.conditional);
assert (remain.autarky == check.autarky);
#endif
// Success if an autarky literal is left in the clause and
// we did not abort the loop too early because the propagation
// limit was hit.
//
if (watched_autarky_literal && stats.condprops < limit) {
assert (is_autarky_literal (watched_autarky_literal));
assert (is_in_candidate_clause (watched_autarky_literal));
blocked++;
stats.conditioned++;
LOG (c, "positive autarky literal %d globally blocks",
watched_autarky_literal);
LOG ("remaining %zd assigned literals %.0f%%", remain.assigned,
percent (remain.assigned, initial.assigned));
LOG ("remaining %zd conditional literals %.0f%%", remain.conditional,
percent (remain.conditional, remain.assigned));
LOG ("remaining %zd autarky literals %.0f%%", remain.autarky,
percent (remain.autarky, remain.assigned));
// A satisfying assignment of a formula after removing a globally
// blocked clause might not satisfy that clause. As for variable
// elimination and classical blocked clauses, we thus maintain an
// extension stack for reconstructing an assignment which both
// satisfies the remaining formula as well as the clause.
//
// For globally blocked clauses we simply have to flip all literals in
// the autarky part and thus save the autarky on the extension stack
// in addition to the removed clause. In the classical situation (in
// bounded variable elimination etc.) we simply save one literal on
// the extension stack.
//
// TODO find a way to shrink the autarky part or some other way to
// avoid pushing too many literals on the extension stack.
//
external->push_zero_on_extension_stack ();
for (const auto &lit : trail)
if (is_autarky_literal (lit))
external->push_witness_literal_on_extension_stack (lit);
external->push_clause_on_extension_stack (c);
mark_garbage (c);
stats.condassrem += remain.assigned;
stats.condcondrem += remain.conditional;
stats.condautrem += remain.autarky;
stats.condassirem += initial.assigned;
}
// In this last part specific to one candidate clause, we have to get
// back to the initial assignment and reset conditionals. First we
// assign all the unassigned literals (if necessary).
//
if (!unassigned.empty ()) {
LOG ("reassigning %zd literals", unassigned.size ());
while (!unassigned.empty ()) {
const int lit = unassigned.back ();
unassigned.pop_back ();
condition_assign (lit);
}
}
// Then we remove from the conditional stack autarky literals which
// became conditional and also reset their 'conditional' bit.
//
if (initial.conditional < conditional.size ()) {
LOG ("flushing %zd autarky literals from conditional stack",
conditional.size () - initial.conditional);
while (initial.conditional < conditional.size ()) {
const int lit = conditional.back ();
conditional.pop_back ();
unmark_as_conditional_literal (lit);
}
}
// Finally unmark all literals in the candidate clause.
//
for (const_literal_iterator l = c->begin (); l != c->end (); l++)
unmark_in_candidate_clause (*l);
} // End of loop over all candidate clauses.
PHASE ("condition", stats.conditionings,
"globally blocked %ld clauses %.0f%%", blocked,
percent (blocked, candidates.size ()));
// Unmark initial conditional variables.
//
for (const auto &lit : conditional)
unmark_as_conditional_literal (lit);
erase_vector (unassigned);
erase_vector (conditional);
erase_vector (candidates);
// Unassign additionally assigned literals.
//
#if defined(LOGGING) || !defined(NDEBUG)
int additionally_unassigned = 0;
#endif
while (trail.size () > initial_trail_level) {
int lit = trail.back ();
trail.pop_back ();
condition_unassign (lit);
#if defined(LOGGING) || !defined(NDEBUG)
additionally_unassigned++;
#endif
}
LOG ("unassigned %d additionally assigned literals",
additionally_unassigned);
assert (additionally_unassigned == additionally_assigned);
if (level > initial_level) {
LOG ("reset condition decision level");
level = initial_level;
}
reset_occs ();
// Reassign previously assigned variables again.
//
LOG ("reassigning previously assigned variables");
for (size_t i = 0; i < initial_trail_level; i++) {
const int lit = trail[i];
const signed char tmp = val (lit);
assert (tmp >= 0);
if (!tmp)
condition_assign (lit);
}
#ifndef NDEBUG
for (const auto &lit : trail)
assert (!marked (lit));
#endif
unprotect_reasons ();
return blocked;
}
void Internal::condition (bool update_limits) {
if (unsat)
return;
if (!stats.current.irredundant)
return;
START_SIMPLIFIER (condition, CONDITION);
stats.conditionings++;
// Propagation limit to avoid too much work in 'condition'. We mark
// tried candidate clauses after giving up, such that next time we run
// 'condition' we can try them.
//
long limit = stats.propagations.search;
limit *= opts.conditionreleff;
limit /= 1000;
if (limit < opts.conditionmineff)
limit = opts.conditionmineff;
if (limit > opts.conditionmaxeff)
limit = opts.conditionmaxeff;
assert (stats.current.irredundant);
limit *= 2.0 * active () / (double) stats.current.irredundant;
limit = max (limit, 2l * active ());
PHASE ("condition", stats.conditionings,
"started after %" PRIu64 " conflicts limited by %ld propagations",
stats.conflicts, limit);
long blocked = condition_round (limit);
STOP_SIMPLIFIER (condition, CONDITION);
report ('g', !blocked);
if (!update_limits)
return;
long delta = opts.conditionint * (stats.conditionings + 1);
lim.condition = stats.conflicts + delta;
PHASE ("condition", stats.conditionings,
"next limit at %" PRIu64 " after %ld conflicts", lim.condition,
delta);
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/config.cpp 0000664 0000000 0000000 00000005004 14501267155 0016430 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
struct NameVal {
const char *name;
int val;
};
/*------------------------------------------------------------------------*/
// These are dummy configurations, which require additional code.
static NameVal default_config[1]; // With '-pedantic' just '[]' or
static NameVal plain_config[1]; // '[0]' gave a warning.
/*------------------------------------------------------------------------*/
// Here we have the pre-defined default configurations.
static NameVal sat_config[] = {
{"elimreleff", 10},
{"stabilizeonly", 1},
{"subsumereleff", 60},
};
static NameVal unsat_config[] = {
{"stabilize", 0},
{"walk", 0},
};
/*------------------------------------------------------------------------*/
#define CONFIGS \
\
CONFIG (default, "set default advanced internal options") \
CONFIG (plain, "disable all internal preprocessing options") \
CONFIG (sat, "set internal options to target satisfiable instances") \
CONFIG (unsat, "set internal options to target unsatisfiable instances")
static const char *configs[] = {
#define CONFIG(N, D) #N,
CONFIGS
#undef CONFIG
};
static size_t num_configs = sizeof configs / sizeof *configs;
/*------------------------------------------------------------------------*/
bool Config::has (const char *name) {
#define CONFIG(N, D) \
if (!strcmp (name, #N)) \
return true;
CONFIGS
#undef CONFIG
return false;
}
bool Config::set (Options &opts, const char *name) {
if (!strcmp (name, "default")) {
opts.reset_default_values ();
return true;
}
if (!strcmp (name, "plain")) {
opts.disable_preprocessing ();
return true;
}
#define CONFIG(N, D) \
do { \
if (strcmp (name, #N)) \
break; \
const NameVal *BEGIN = N##_config; \
const NameVal *END = BEGIN + sizeof N##_config / sizeof (NameVal); \
for (const NameVal *P = BEGIN; P != END; P++) { \
assert (Options::has (P->name)); \
opts.set (P->name, P->val); \
} \
return true; \
} while (0);
CONFIGS
#undef CONFIG
return false;
}
/*------------------------------------------------------------------------*/
void Config::usage () {
#define CONFIG(N, D) printf (" %-14s " D "\n", "--" #N);
CONFIGS
#undef CONFIG
}
/*------------------------------------------------------------------------*/
const char **Config::begin () { return configs; }
const char **Config::end () { return &configs[num_configs]; }
} // namespace CaDiCaL
cadical-rel-1.7.4/src/config.hpp 0000664 0000000 0000000 00000000472 14501267155 0016441 0 ustar 00root root 0000000 0000000 #ifndef _config_hpp_INCLUDED
#define _config_hpp_INCLUDED
namespace CaDiCaL {
class Options;
struct Config {
static bool has (const char *);
static bool set (Options &, const char *);
static void usage ();
static const char **begin ();
static const char **end ();
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/configure 0000777 0000000 0000000 00000000000 14501267155 0020476 2../configure ustar 00root root 0000000 0000000 cadical-rel-1.7.4/src/constrain.cpp 0000664 0000000 0000000 00000003225 14501267155 0017166 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
void Internal::constrain (int lit) {
if (lit)
constraint.push_back (lit);
else {
if (level)
backtrack ();
LOG (constraint, "shrinking constraint");
bool satisfied_constraint = false;
const vector::const_iterator end = constraint.end ();
vector::iterator i = constraint.begin ();
for (vector::const_iterator j = i; j != end; j++) {
int tmp = marked (*j);
if (tmp > 0) {
LOG ("removing duplicated literal %d from constraint", *j);
} else if (tmp < 0) {
LOG ("tautological since both %d and %d occur in constraint", -*j,
*j);
satisfied_constraint = true;
break;
} else {
tmp = val (*j);
if (tmp < 0) {
LOG ("removing falsified literal %d from constraint clause", *j);
} else if (tmp > 0) {
LOG ("satisfied constraint with literal %d", *j);
satisfied_constraint = true;
break;
} else {
*i++ = *j;
mark (*j);
}
}
}
constraint.resize (i - constraint.begin ());
for (const auto &lit : constraint)
unmark (lit);
if (satisfied_constraint)
constraint.clear ();
else if (constraint.empty ())
unsat_constraint = true;
else
for (const auto lit : constraint)
freeze (lit);
}
}
bool Internal::failed_constraint () { return unsat_constraint; }
void Internal::reset_constraint () {
for (auto lit : constraint)
melt (lit);
LOG ("cleared %zd constraint literals", constraint.size ());
constraint.clear ();
unsat_constraint = false;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/contract.cpp 0000664 0000000 0000000 00000001201 14501267155 0016773 0 ustar 00root root 0000000 0000000 #ifndef NCONTRACTS
#include "internal.hpp"
namespace CaDiCaL {
void fatal_message_start ();
// See comments in 'contract.hpp'. Ugly hack we keep for now.
void require_solver_pointer_to_be_non_zero (const void *ptr,
const char *function_name,
const char *file_name) {
if (ptr)
return;
fatal_message_start ();
fprintf (stderr,
"invalid API usage of '%s' in '%s': "
"solver 'this' pointer zero (not initialized)\n",
function_name, file_name);
fflush (stderr);
abort ();
}
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/contract.hpp 0000664 0000000 0000000 00000010130 14501267155 0017001 0 ustar 00root root 0000000 0000000 #ifndef _contract_hpp_INCLUDED
#define _contract_hpp_INCLUDED
/*------------------------------------------------------------------------*/
#ifndef NCONTRACTS
/*------------------------------------------------------------------------*/
// If the user violates API contracts while calling functions declared in
// 'cadical.hpp' and implemented in 'solver.cpp' then an error is reported.
// Currently we also force aborting the program. In the future it might be
// better to allow the user to provide a call back function, which then can
// for instance throw a C++ exception or execute a 'longjmp' in 'C' etc.
#define CONTRACT_VIOLATED(...) \
do { \
fatal_message_start (); \
fprintf (stderr, \
"invalid API usage of '%s' in '%s': ", __PRETTY_FUNCTION__, \
__FILE__); \
fprintf (stderr, __VA_ARGS__); \
fputc ('\n', stderr); \
fflush (stderr); \
abort (); \
} while (0)
/*------------------------------------------------------------------------*/
namespace CaDiCaL {
// It would be much easier to just write 'REQUIRE (this, "not initialized")'
// which however produces warnings due to the '-Wnonnull' check. Note, that
// 'this' is always assumed to be non zero in modern C++. Much worse, if we
// use instead 'this != 0' or something similar like 'this != nullptr' then
// optimization silently removes this check ('gcc-7.4.0' at least) even
// though of course a zero pointer might be used as 'this' if the user did
// not initialize it. The only solution I found is to disable optimization
// for this check. It does not seem to be necessary for 'clang++' though
// ('clang++-6.0.0' at least). The alternative is to not check that the
// user forgot to initialize the solver pointer, but as long this works we
// keep this ugly hack. It also forces the function not to be inlined.
// The actual code I is in 'contract.cpp'.
//
void require_solver_pointer_to_be_non_zero (const void *ptr,
const char *function_name,
const char *file_name);
#define REQUIRE_NON_ZERO_THIS() \
do { \
require_solver_pointer_to_be_non_zero (this, __PRETTY_FUNCTION__, \
__FILE__); \
} while (0)
} // namespace CaDiCaL
/*------------------------------------------------------------------------*/
// These are common shortcuts for 'Solver' API contracts (requirements).
#define REQUIRE(COND, ...) \
do { \
if ((COND)) \
break; \
CONTRACT_VIOLATED (__VA_ARGS__); \
} while (0)
#define REQUIRE_INITIALIZED() \
do { \
REQUIRE_NON_ZERO_THIS (); \
REQUIRE (external, "external solver not initialized"); \
REQUIRE (internal, "internal solver not initialized"); \
} while (0)
#define REQUIRE_VALID_STATE() \
do { \
REQUIRE_INITIALIZED (); \
REQUIRE (this->state () & VALID, "solver in invalid state"); \
} while (0)
#define REQUIRE_READY_STATE() \
do { \
REQUIRE_VALID_STATE (); \
REQUIRE (state () != ADDING, \
"clause incomplete (terminating zero not added)"); \
} while (0)
#define REQUIRE_VALID_OR_SOLVING_STATE() \
do { \
REQUIRE_INITIALIZED (); \
REQUIRE (this->state () & (VALID | SOLVING), \
"solver neither in valid nor solving state"); \
} while (0)
#define REQUIRE_VALID_LIT(LIT) \
do { \
REQUIRE ((int) (LIT) && ((int) (LIT)) != INT_MIN, \
"invalid literal '%d'", (int) (LIT)); \
} while (0)
/*------------------------------------------------------------------------*/
#else // NCONTRACTS
/*------------------------------------------------------------------------*/
#define REQUIRE(...) \
do { \
} while (0)
#define REQUIRE_INITIALIZED() \
do { \
} while (0)
#define REQUIRE_VALID_STATE() \
do { \
} while (0)
#define REQUIRE_READY_STATE() \
do { \
} while (0)
#define REQUIRE_VALID_OR_SOLVING_STATE() \
do { \
} while (0)
#define REQUIRE_VALID_LIT(...) \
do { \
} while (0)
/*------------------------------------------------------------------------*/
#endif
/*------------------------------------------------------------------------*/
#endif
cadical-rel-1.7.4/src/cover.cpp 0000664 0000000 0000000 00000045603 14501267155 0016312 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// Covered clause elimination (CCE) is described in our short LPAR-10 paper
// and later in more detail in our JAIR'15 article. Actually implement
// the asymmetric version which adds asymmetric literals too but still call
// it 'CCE' in the following (and not 'ACCE'). This implementation provides
// a simplified and cleaner version of the one implemented before in
// Lingeling. We still follow quite closely the original description in the
// literature, which is based on asymmetric literal addition (ALA) and
// covered literal addition (CLA). Both can be seen as kind of propagation,
// where the literals in the original and then extended clause are assigned
// to false, and the literals on the trail (actually we use our own 'added'
// stack for that) make up the extended clause. The ALA steps can be
// implemented by simple propagation (copied from 'propagate.cpp') using
// watches, while the CLA steps need full occurrence lists to determine the
// resolution candidate clauses. The CCE is successful if a conflict is
// found during ALA steps or if during a CLA step all resolution candidates
// of a literal on the trail are satisfied (the extended clause is blocked).
struct Coveror {
std::vector added; // acts as trail
std::vector extend; // extension stack for witness
std::vector covered; // clause literals or added through CLA
std::vector intersection; // of literals in resolution candidates
size_t alas, clas; // actual number of ALAs and CLAs
struct {
size_t added, covered;
} next; // propagate next ...
Coveror () : alas (0), clas (0) {}
};
/*------------------------------------------------------------------------*/
// Push on the extension stack a clause made up of the given literal, the
// original clause (initially copied to 'covered') and all the added covered
// literals so far. The given literal will act as blocking literal for that
// clause, if CCE is successful. Only in this case, this private extension
// stack is copied to the actual extension stack of the solver. Note, that
// even though all 'added' clauses correspond to the extended clause, we
// only need to save the original and added covered literals.
inline void Internal::cover_push_extension (int lit, Coveror &coveror) {
coveror.extend.push_back (0);
coveror.extend.push_back (lit); // blocking literal comes first
bool found = false;
for (const auto &other : coveror.covered)
if (lit == other)
assert (!found), found = true;
else
coveror.extend.push_back (other);
assert (found);
(void) found;
}
// Successful covered literal addition (CLA) step.
inline void Internal::covered_literal_addition (int lit, Coveror &coveror) {
require_mode (COVER);
assert (level == 1);
cover_push_extension (lit, coveror);
for (const auto &other : coveror.intersection) {
LOG ("covered literal addition %d", other);
assert (!vals[other]), assert (!vals[-other]);
vals[other] = -1, vals[-other] = 1;
coveror.covered.push_back (other);
coveror.added.push_back (other);
coveror.clas++;
}
coveror.next.covered = 0;
}
// Successful asymmetric literal addition (ALA) step.
inline void Internal::asymmetric_literal_addition (int lit,
Coveror &coveror) {
require_mode (COVER);
assert (level == 1);
LOG ("initial asymmetric literal addition %d", lit);
assert (!vals[lit]), assert (!vals[-lit]);
vals[lit] = -1, vals[-lit] = 1;
coveror.added.push_back (lit);
coveror.alas++;
coveror.next.covered = 0;
}
/*------------------------------------------------------------------------*/
// In essence copied and adapted from 'propagate' in 'propagate.cpp'. Since
// this function is also a hot-spot here in 'cover' we specialize it in the
// same spirit as 'probe_propagate' and 'vivify_propagate'. Please refer to
// the detailed comments for 'propagate' in 'propagate.cpp' for details.
bool Internal::cover_propagate_asymmetric (int lit, Clause *ignore,
Coveror &coveror) {
require_mode (COVER);
stats.propagations.cover++;
assert (val (lit) < 0);
bool subsumed = false;
LOG ("asymmetric literal propagation of %d", lit);
Watches &ws = watches (lit);
const const_watch_iterator eow = ws.end ();
watch_iterator j = ws.begin ();
const_watch_iterator i = j;
while (!subsumed && i != eow) {
const Watch w = *j++ = *i++;
if (w.clause == ignore)
continue; // costly but necessary here ...
const signed char b = val (w.blit);
if (b > 0)
continue;
if (w.clause->garbage)
j--;
else if (w.binary ()) {
if (b < 0) {
LOG (w.clause, "found subsuming");
subsumed = true;
} else
asymmetric_literal_addition (-w.blit, coveror);
} else {
literal_iterator lits = w.clause->begin ();
const int other = lits[0] ^ lits[1] ^ lit;
lits[0] = other, lits[1] = lit;
const signed char u = val (other);
if (u > 0)
j[-1].blit = other;
else {
const int size = w.clause->size;
const const_literal_iterator end = lits + size;
const literal_iterator middle = lits + w.clause->pos;
literal_iterator k = middle;
signed char v = -1;
int r = 0;
while (k != end && (v = val (r = *k)) < 0)
k++;
if (v < 0) {
k = lits + 2;
assert (w.clause->pos <= size);
while (k != middle && (v = val (r = *k)) < 0)
k++;
}
w.clause->pos = k - lits;
assert (lits + 2 <= k), assert (k <= w.clause->end ());
if (v > 0)
j[-1].blit = r;
else if (!v) {
LOG (w.clause, "unwatch %d in", lit);
lits[1] = r;
*k = lit;
watch_literal (r, lit, w.clause);
j--;
} else if (!u) {
assert (v < 0);
asymmetric_literal_addition (-other, coveror);
} else {
assert (u < 0), assert (v < 0);
LOG (w.clause, "found subsuming");
subsumed = true;
break;
}
}
}
}
if (j != i) {
while (i != eow)
*j++ = *i++;
ws.resize (j - ws.begin ());
}
return subsumed;
}
// Covered literal addition (which needs full occurrence lists). The
// function returns 'true' if the extended clause is blocked on 'lit.'
bool Internal::cover_propagate_covered (int lit, Coveror &coveror) {
require_mode (COVER);
assert (val (lit) < 0);
if (frozen (lit)) {
LOG ("no covered propagation on frozen literal %d", lit);
return false;
}
stats.propagations.cover++;
LOG ("covered propagation of %d", lit);
assert (coveror.intersection.empty ());
Occs &os = occs (-lit);
const auto end = os.end ();
bool first = true;
// Compute the intersection of the literals in all the clauses with
// '-lit'. If all these clauses are double satisfied then we know that
// the extended clauses (in 'added') is blocked. All literals in the
// intersection can be added as covered literal. As soon the intersection
// becomes empty (during traversal of clauses with '-lit') we abort.
for (auto i = os.begin (); i != end; i++) {
Clause *c = *i;
if (c->garbage)
continue;
// First check whether clause is 'blocked', i.e., is double satisfied.
bool blocked = false;
for (const auto &other : *c) {
if (other == -lit)
continue;
const signed char tmp = val (other);
if (tmp < 0)
continue;
if (tmp > 0) {
blocked = true;
break;
}
}
if (blocked) { // ... if 'c' is double satisfied.
LOG (c, "blocked");
continue; // with next clause with '-lit'.
}
if (first) {
// Copy and mark literals of first clause.
for (const auto &other : *c) {
if (other == -lit)
continue;
const signed char tmp = val (other);
if (tmp < 0)
continue;
assert (!tmp);
coveror.intersection.push_back (other);
mark (other);
}
first = false;
} else {
// Unmark all literals in current clause.
for (const auto &other : *c) {
if (other == -lit)
continue;
signed char tmp = val (other);
if (tmp < 0)
continue;
assert (!tmp);
tmp = marked (other);
if (tmp > 0)
unmark (other);
}
// Then remove from intersection all marked literals.
const auto end = coveror.intersection.end ();
auto j = coveror.intersection.begin ();
for (auto k = j; k != end; k++) {
const int other = *j++ = *k;
const int tmp = marked (other);
assert (tmp >= 0);
if (tmp)
j--, unmark (other); // remove marked and unmark it
else
mark (other); // keep unmarked and mark it
}
const size_t new_size = j - coveror.intersection.begin ();
coveror.intersection.resize (new_size);
if (!coveror.intersection.empty ())
continue;
// No covered literal addition candidates in the intersection left!
// Move this clause triggering early abort to the beginning.
// This is a common move to front strategy to minimize effort.
auto begin = os.begin ();
while (i != begin) {
auto prev = i - 1;
*i = *prev;
i = prev;
}
*begin = c;
break; // early abort ...
}
}
bool res = false;
if (first) {
LOG ("all resolution candidates with %d blocked", -lit);
assert (coveror.intersection.empty ());
cover_push_extension (lit, coveror);
res = true;
} else if (coveror.intersection.empty ()) {
LOG ("empty intersection of resolution candidate literals");
} else {
LOG (coveror.intersection,
"non-empty intersection of resolution candidate literals");
covered_literal_addition (lit, coveror);
unmark (coveror.intersection);
coveror.intersection.clear ();
coveror.next.covered = 0; // Restart covering.
}
unmark (coveror.intersection);
coveror.intersection.clear ();
return res;
}
/*------------------------------------------------------------------------*/
bool Internal::cover_clause (Clause *c, Coveror &coveror) {
require_mode (COVER);
assert (!c->garbage);
LOG (c, "trying covered clauses elimination on");
bool satisfied = false;
for (const auto &lit : *c)
if (val (lit) > 0)
satisfied = true;
if (satisfied) {
LOG (c, "clause already satisfied");
mark_garbage (c);
return false;
}
assert (coveror.added.empty ());
assert (coveror.extend.empty ());
assert (coveror.covered.empty ());
assert (!level);
level = 1;
LOG ("assuming literals of candidate clause");
for (const auto &lit : *c) {
if (val (lit))
continue;
asymmetric_literal_addition (lit, coveror);
coveror.covered.push_back (lit);
}
bool tautological = false;
coveror.next.added = coveror.next.covered = 0;
while (!tautological) {
if (coveror.next.added < coveror.added.size ()) {
const int lit = coveror.added[coveror.next.added++];
tautological = cover_propagate_asymmetric (lit, c, coveror);
} else if (coveror.next.covered < coveror.covered.size ()) {
const int lit = coveror.covered[coveror.next.covered++];
tautological = cover_propagate_covered (lit, coveror);
} else
break;
}
if (tautological) {
if (coveror.extend.empty ()) {
stats.cover.asymmetric++;
stats.cover.total++;
LOG (c, "asymmetric tautological");
mark_garbage (c);
} else {
stats.cover.blocked++;
stats.cover.total++;
LOG (c, "covered tautological");
mark_garbage (c);
// Only copy extension stack if successful.
int prev = INT_MIN;
for (const auto &other : coveror.extend) {
if (!prev) {
external->push_zero_on_extension_stack ();
external->push_witness_literal_on_extension_stack (other);
external->push_zero_on_extension_stack ();
}
if (other)
external->push_clause_literal_on_extension_stack (other);
prev = other;
}
}
}
// Backtrack and 'unassign' all literals.
assert (level == 1);
for (const auto &lit : coveror.added)
vals[lit] = vals[-lit] = 0;
level = 0;
coveror.covered.clear ();
coveror.extend.clear ();
coveror.added.clear ();
return tautological;
}
/*------------------------------------------------------------------------*/
// Not yet tried and larger clauses are tried first.
struct clause_covered_or_smaller {
bool operator() (const Clause *a, const Clause *b) {
if (a->covered && !b->covered)
return true;
if (!a->covered && b->covered)
return false;
return a->size < b->size;
}
};
int64_t Internal::cover_round () {
if (unsat)
return 0;
init_watches ();
connect_watches (true); // irredundant watches only is enough
int64_t delta = stats.propagations.search;
delta *= 1e-3 * opts.coverreleff;
if (delta < opts.covermineff)
delta = opts.covermineff;
if (delta > opts.covermaxeff)
delta = opts.covermaxeff;
delta = max (delta, ((int64_t) 2) * active ());
PHASE ("cover", stats.cover.count,
"covered clause elimination limit of %" PRId64 " propagations",
delta);
int64_t limit = stats.propagations.cover + delta;
init_occs ();
vector schedule;
Coveror coveror;
// First connect all clauses and find all not yet tried clauses.
//
#ifndef QUIET
int64_t untried = 0;
#endif
//
for (auto c : clauses) {
assert (!c->frozen);
if (c->garbage)
continue;
if (c->redundant)
continue;
bool satisfied = false, allfrozen = true;
for (const auto &lit : *c)
if (val (lit) > 0) {
satisfied = true;
break;
} else if (allfrozen && !frozen (lit))
allfrozen = false;
if (satisfied) {
mark_garbage (c);
continue;
}
if (allfrozen) {
c->frozen = true;
continue;
}
for (const auto &lit : *c)
occs (lit).push_back (c);
if (c->size < opts.coverminclslim)
continue;
if (c->size > opts.covermaxclslim)
continue;
if (c->covered)
continue;
schedule.push_back (c);
#ifndef QUIET
untried++;
#endif
}
if (schedule.empty ()) {
PHASE ("cover", stats.cover.count, "no previously untried clause left");
for (auto c : clauses) {
if (c->garbage)
continue;
if (c->redundant)
continue;
if (c->frozen) {
c->frozen = false;
continue;
}
if (c->size < opts.coverminclslim)
continue;
if (c->size > opts.covermaxclslim)
continue;
assert (c->covered);
c->covered = false;
schedule.push_back (c);
}
} else { // Mix of tried and not tried clauses ....
for (auto c : clauses) {
if (c->garbage)
continue;
if (c->redundant)
continue;
if (c->frozen) {
c->frozen = false;
continue;
}
if (c->size < opts.coverminclslim)
continue;
if (c->size > opts.covermaxclslim)
continue;
if (!c->covered)
continue;
schedule.push_back (c);
}
}
stable_sort (schedule.begin (), schedule.end (),
clause_covered_or_smaller ());
#ifndef QUIET
const size_t scheduled = schedule.size ();
PHASE ("cover", stats.cover.count,
"scheduled %zd clauses %.0f%% with %" PRId64 " untried %.0f%%",
scheduled, percent (scheduled, stats.current.irredundant), untried,
percent (untried, scheduled));
#endif
// Heuristically it should be beneficial to intersect with smaller clauses
// first, since then the chances are higher that the intersection of
// resolution candidates becomes emptier earlier.
for (auto lit : lits) {
if (!active (lit))
continue;
Occs &os = occs (lit);
stable_sort (os.begin (), os.end (), clause_smaller_size ());
}
// This is the main loop of trying to do CCE of candidate clauses.
//
int64_t covered = 0;
//
while (!terminated_asynchronously () && !schedule.empty () &&
stats.propagations.cover < limit) {
Clause *c = schedule.back ();
schedule.pop_back ();
c->covered = true;
if (cover_clause (c, coveror))
covered++;
}
#ifndef QUIET
const size_t remain = schedule.size ();
const size_t tried = scheduled - remain;
PHASE ("cover", stats.cover.count,
"eliminated %" PRId64 " covered clauses out of %zd tried %.0f%%",
covered, tried, percent (covered, tried));
if (remain)
PHASE ("cover", stats.cover.count,
"remaining %zu clauses %.0f%% untried", remain,
percent (remain, scheduled));
else
PHASE ("cover", stats.cover.count, "all scheduled clauses tried");
#endif
reset_occs ();
reset_watches ();
return covered;
}
/*------------------------------------------------------------------------*/
bool Internal::cover () {
if (!opts.cover)
return false;
if (unsat)
return false;
if (terminated_asynchronously ())
return false;
if (!stats.current.irredundant)
return false;
// TODO: Our current algorithm for producing the necessary clauses on the
// reconstruction stack for extending the witness requires a covered
// literal addition step which (empirically) conflicts with flushing
// during restoring clauses (see 'regr00{48,51}.trace') even though
// flushing during restore is disabled by default (as is covered clause
// elimination). The consequence of combining these two options
// ('opts.cover' and 'opts.restoreflush') can thus produce incorrect
// witness reconstruction and thus invalid witnesses. This is quite
// infrequent (one out of half billion mobical test cases) but as the two
// regression traces show, does happen. Thus we disable the combination.
//
if (opts.restoreflush)
return false;
START_SIMPLIFIER (cover, COVER);
stats.cover.count++;
// During variable elimination unit clauses can be generated which need to
// be propagated properly over redundant clauses too. Since variable
// elimination avoids to have occurrence lists and watches at the same
// time this propagation is delayed until the end of variable elimination.
// Since we want to interleave CCE with it, we have to propagate here.
// Otherwise this triggers inconsistencies.
//
if (propagated < trail.size ()) {
init_watches ();
connect_watches (); // need to propagated over all clauses!
LOG ("elimination produced %zd units",
(size_t) (trail.size () - propagated));
if (!propagate ()) {
LOG ("propagating units before covered clause elimination "
"results in empty clause");
learn_empty_clause ();
assert (unsat);
}
reset_watches ();
}
assert (unsat || propagated == trail.size ());
int64_t covered = cover_round ();
STOP_SIMPLIFIER (cover, COVER);
report ('c', !opts.reportall && !covered);
return covered;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/cover.hpp 0000664 0000000 0000000 00000002306 14501267155 0016310 0 ustar 00root root 0000000 0000000 #ifndef _cover_hpp_INCLUDED
#define _cover_hpp_INCLUDED
/*------------------------------------------------------------------------*/
// This header only provides the 'COVER' macro for testing. It is unrelated
// to 'cover.cpp' which implements covered clause elimination (CCE), but we
// wanted to use the name base name in both cases. More explanation on CCE
// is provided in 'cover.cpp'.
/*------------------------------------------------------------------------*/
// Coverage goal, used similar to 'assert' (but with flipped condition) and
// also included even if 'NDEBUG' is defined (in optimizing compilation).
//
// This should in essence not be used in production code.
//
// There seems to be no problem overloading the name 'COVER' of this macro
// with the constant 'COVER' of 'Internal::Mode' (surprisingly).
#define COVER(COND) \
do { \
if (!(COND)) \
break; \
fprintf (stderr, \
"%scadical%s: %s:%d: %s: Coverage goal %s`%s'%s reached.\n", \
terr.bold_code (), terr.normal_code (), __FUNCTION__, \
__LINE__, __FILE__, terr.green_code (), #COND, \
terr.normal_code ()); \
fflush (stderr); \
abort (); \
} while (0)
#endif
cadical-rel-1.7.4/src/decide.cpp 0000664 0000000 0000000 00000015270 14501267155 0016406 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
// This function determines the next decision variable on the queue, without
// actually removing it from the decision queue, e.g., calling it multiple
// times without any assignment will return the same result. This is of
// course used below in 'decide' but also in 'reuse_trail' to determine the
// largest decision level to backtrack to during 'restart' without changing
// the assigned variables (if 'opts.restartreusetrail' is non-zero).
int Internal::next_decision_variable_on_queue () {
int64_t searched = 0;
int res = queue.unassigned;
while (val (res))
res = link (res).prev, searched++;
if (searched) {
stats.searched += searched;
update_queue_unassigned (res);
}
LOG ("next queue decision variable %d bumped %" PRId64 "", res,
bumped (res));
return res;
}
// This function determines the best decision with respect to score.
//
int Internal::next_decision_variable_with_best_score () {
int res = 0;
for (;;) {
res = scores.front ();
if (!val (res))
break;
(void) scores.pop_front ();
}
LOG ("next decision variable %d with score %g", res, score (res));
return res;
}
int Internal::next_decision_variable () {
if (use_scores ())
return next_decision_variable_with_best_score ();
else
return next_decision_variable_on_queue ();
}
/*------------------------------------------------------------------------*/
// Implements phase saving as well using a target phase during
// stabilization unless decision phase is forced to the initial value
// of a phase is forced through the 'phase' option.
int Internal::decide_phase (int idx, bool target) {
const int initial_phase = opts.phase ? 1 : -1;
int phase = 0;
if (force_saved_phase)
phase = phases.saved[idx];
if (!phase)
phase = phases.forced[idx]; // swapped with opts.forcephase case!
if (!phase && opts.forcephase)
phase = initial_phase;
if (!phase && target)
phase = phases.target[idx];
if (!phase)
phase = phases.saved[idx];
// The following should not be necessary and in some version we had even
// a hard 'COVER' assertion here to check for this. Unfortunately it
// triggered for some users and we could not get to the root cause of
// 'phase' still not being set here. The logic for phase and target
// saving is pretty complex, particularly in combination with local
// search, and to avoid running in such an issue in the future again, we
// now use this 'defensive' code here, even though such defensive code is
// considered bad programming practice.
//
if (!phase)
phase = initial_phase;
return phase * idx;
}
// The likely phase of an variable used in 'collect' for optimizing
// co-location of clauses likely accessed together during search.
int Internal::likely_phase (int idx) { return decide_phase (idx, false); }
/*------------------------------------------------------------------------*/
bool Internal::satisfied () {
size_t assigned = trail.size ();
if (propagated < assigned)
return false;
if ((size_t) level < assumptions.size () + (!!constraint.size ()))
return false;
return (assigned == (size_t) max_var);
}
bool Internal::better_decision (int lit, int other) {
int lit_idx = abs (lit);
int other_idx = abs (other);
if (stable)
return stab[lit_idx] > stab[other_idx];
else
return btab[lit_idx] > btab[other_idx];
}
// Search for the next decision and assign it to the saved phase. Requires
// that not all variables are assigned.
int Internal::decide () {
assert (!satisfied ());
START (decide);
int res = 0;
if ((size_t) level < assumptions.size ()) {
const int lit = assumptions[level];
assert (assumed (lit));
const signed char tmp = val (lit);
if (tmp < 0) {
LOG ("assumption %d falsified", lit);
res = 20;
} else if (tmp > 0) {
LOG ("assumption %d already satisfied", lit);
level++;
control.push_back (Level (0, trail.size ()));
LOG ("added pseudo decision level");
notify_decision ();
} else {
LOG ("deciding assumption %d", lit);
search_assume_decision (lit);
}
} else if ((size_t) level == assumptions.size () && constraint.size ()) {
int satisfied_lit = 0; // The literal satisfying the constrain.
int unassigned_lit = 0; // Highest score unassigned literal.
int previous_lit = 0; // Move satisfied literals to the front.
const size_t size_constraint = constraint.size ();
#ifndef NDEBUG
unsigned sum = 0;
for (auto lit : constraint)
sum += lit;
#endif
for (size_t i = 0; i != size_constraint; i++) {
// Get literal and move 'constraint[i] = constraint[i-1]'.
int lit = constraint[i];
constraint[i] = previous_lit;
previous_lit = lit;
const signed char tmp = val (lit);
if (tmp < 0) {
LOG ("constraint literal %d falsified", lit);
continue;
}
if (tmp > 0) {
LOG ("constraint literal %d satisfied", lit);
satisfied_lit = lit;
break;
}
assert (!tmp);
LOG ("constraint literal %d unassigned", lit);
if (!unassigned_lit || better_decision (lit, unassigned_lit))
unassigned_lit = lit;
}
if (satisfied_lit) {
constraint[0] = satisfied_lit; // Move satisfied to the front.
LOG ("literal %d satisfies constraint and "
"is implied by assumptions",
satisfied_lit);
level++;
control.push_back (Level (0, trail.size ()));
LOG ("added pseudo decision level for constraint");
notify_decision ();
} else {
// Just move all the literals back. If we found an unsatisfied
// literal then it will be satisfied (most likely) at the next
// decision and moved then to the first position.
if (size_constraint) {
for (size_t i = 0; i + 1 != size_constraint; i++)
constraint[i] = constraint[i + 1];
constraint[size_constraint - 1] = previous_lit;
}
if (unassigned_lit) {
LOG ("deciding %d to satisfy constraint", unassigned_lit);
search_assume_decision (unassigned_lit);
} else {
LOG ("failing constraint");
unsat_constraint = true;
res = 20;
}
}
#ifndef NDEBUG
for (auto lit : constraint)
sum -= lit;
assert (!sum); // Checksum of literal should not change!
#endif
} else {
stats.decisions++;
int decision = ask_decision ();
if (!decision) {
int idx = next_decision_variable ();
const bool target = (opts.target > 1 || (stable && opts.target));
decision = decide_phase (idx, target);
}
search_assume_decision (decision);
}
if (res)
marked_failed = false;
STOP (decide);
return res;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/decompose.cpp 0000664 0000000 0000000 00000051152 14501267155 0017146 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
void Internal::decompose_analyze_binary_chain (DFS *dfs, int from) {
if (!opts.lrat || opts.lratexternal)
return;
LOG ("binary chain starting at %d", from);
DFS &from_dfs = dfs[vlit (from)];
Clause *reason = from_dfs.parent;
/*
if (val (from) > 0) {
const unsigned uidx = vlit (from);
uint64_t id = unit_clauses[uidx];
assert (id);
mini_chain.push_back (id);
return;
}
*/
if (!reason)
return;
assert (reason->size == 2);
mini_chain.push_back (reason->id);
int other = reason->literals[0];
other = other == from ? -reason->literals[1] : -other;
Flags &f = flags (other);
if (f.seen)
return;
f.seen = true;
analyzed.push_back (other);
decompose_analyze_binary_chain (dfs, other);
}
vector Internal::decompose_analyze_binary_clauses (DFS *dfs,
int from) {
vector result;
LOG ("binary chain starting at %d", from);
DFS &from_dfs = dfs[vlit (from)];
Clause *reason = from_dfs.parent;
while (reason) {
result.push_back (reason);
assert (reason->size == 2);
int other = reason->literals[0];
other = other == from ? -reason->literals[1] : -other;
Flags &f = flags (other);
if (f.seen)
break;
f.seen = true;
analyzed.push_back (other);
from = other;
DFS &from_dfs = dfs[vlit (from)];
reason = from_dfs.parent;
}
return result;
}
void Internal::decompose_conflicting_scc_lrat (DFS *dfs, vector &scc) {
if (!opts.lrat || opts.lratexternal)
return;
assert (lrat_chain.empty ());
assert (mini_chain.empty ());
for (auto &lit : scc) {
Flags &f = flags (lit);
if (f.seen)
return;
f.seen = true;
analyzed.push_back (lit);
decompose_analyze_binary_chain (dfs, lit);
for (auto p = mini_chain.rbegin (); p != mini_chain.rend (); p++) {
lrat_chain.push_back (*p);
}
/*
if (back)
for (auto p = mini_chain.rbegin (); p != mini_chain.rend (); p++) {
lrat_chain.push_back (*p);
}
else
for (auto p : mini_chain) {
lrat_chain.push_back (p);
}
*/
mini_chain.clear ();
}
clear_analyzed_literals ();
}
void Internal::clear_decomposed_literals () {
LOG ("clearing %zd decomposed literals", decomposed.size ());
for (const auto &lit : decomposed) {
assert (marked_decompose (lit));
unmark_decompose (lit);
}
decomposed.clear ();
}
// compute lrat_chain from a given starting reason to root
//
void Internal::decompose_analyze_lrat (DFS *dfs, Clause *reason) {
if (!opts.lrat || opts.lratexternal)
return;
assert (lrat_chain.empty ());
assert (reason); // not sure yet.
LOG (reason, "decompose analyze for");
for (const auto lit : *reason) {
const auto other = -lit;
Flags &f = flags (other);
if (f.seen)
continue;
f.seen = true;
analyzed.push_back (other);
if (val (other) > 0) {
const unsigned uidx = vlit (other);
uint64_t id = unit_clauses[uidx];
assert (id);
lrat_chain.push_back (id);
continue;
}
assert (mini_chain.empty ());
decompose_analyze_binary_chain (dfs, other);
for (auto p = mini_chain.rbegin (); p != mini_chain.rend (); p++) {
lrat_chain.push_back (*p);
}
mini_chain.clear ();
}
lrat_chain.push_back (reason->id);
clear_analyzed_literals ();
}
// This performs one round of Tarjan's algorithm, e.g., equivalent literal
// detection and substitution, on the whole formula. We might want to
// repeat it since its application might produce new binary clauses or
// units. Such units might even result in an empty clause.
bool Internal::decompose_round () {
if (!opts.decompose)
return false;
if (unsat)
return false;
if (terminated_asynchronously ())
return false;
assert (!level);
START_SIMPLIFIER (decompose, DECOMP);
stats.decompositions++;
const size_t size_dfs = 2 * (1 + (size_t) max_var);
DFS *dfs = new DFS[size_dfs];
int *reprs = new int[size_dfs];
clear_n (reprs, size_dfs);
vector> dfs_chains;
dfs_chains.resize (size_dfs);
if (opts.lrat && !opts.lratexternal) {
for (size_t i = 0; i > size_dfs; i++) {
vector empty;
dfs_chains[i] = empty;
}
}
int substituted = 0;
#ifndef QUIET
int non_trivial_sccs = 0;
int before = active ();
#endif
unsigned dfs_idx = 0;
vector work; // depth first search working stack
vector scc; // collects members of one SCC
// The binary implication graph might have disconnected components and
// thus we have in general to start several depth first searches.
for (auto root_idx : vars) {
if (unsat)
break;
if (!active (root_idx))
continue;
for (int root_sign = -1; !unsat && root_sign <= 1; root_sign += 2) {
int root = root_sign * root_idx;
if (dfs[vlit (root)].min == TRAVERSED)
continue; // skip traversed
LOG ("new dfs search starting at root %d", root);
assert (work.empty ());
assert (scc.empty ());
work.push_back (root);
while (!unsat && !work.empty ()) {
int parent = work.back ();
DFS &parent_dfs = dfs[vlit (parent)];
if (parent_dfs.min == TRAVERSED) { // skip traversed
assert (reprs[vlit (parent)]);
work.pop_back ();
} else {
assert (!reprs[vlit (parent)]);
// Go over all implied literals, thus need to iterate over all
// binary watched clauses with the negation of 'parent'.
Watches &ws = watches (-parent);
// Two cases: Either the node has never been visited before, i.e.,
// it's depth first search index is zero, then perform the
// 'pre-fix' work before visiting it's children. Otherwise all
// it's children and nodes reachable from those children have been
// visited and their minimum reachable depth first search index
// has been computed. This second case is the 'post-fix' work.
if (parent_dfs.idx) { // post-fix
work.pop_back (); // 'parent' done
// Get the minimum reachable depth first search index reachable
// from the children of 'parent'.
unsigned new_min = parent_dfs.min;
for (const auto &w : ws) {
if (!w.binary ())
continue;
const int child = w.blit;
if (!active (child))
continue;
DFS &child_dfs = dfs[vlit (child)];
if (new_min > child_dfs.min)
new_min = child_dfs.min;
}
LOG ("post-fix work dfs search %d index %u reaches minimum %u",
parent, parent_dfs.idx, new_min);
if (parent_dfs.idx == new_min) { // entry to SCC
// All nodes on the 'scc' stack after and including 'parent'
// are in the same SCC. Their representative is computed as
// the smallest literal (index-wise) in the SCC. If the SCC
// contains both a literal and its negation, then the formula
// becomes unsatisfiable.
if (opts.lrat && !opts.lratexternal) {
assert (analyzed.empty ());
int other, first = 0;
bool conflicting = false;
size_t j = scc.size ();
do {
assert (j > 0);
other = scc[--j];
if (!first || vlit (other) < vlit (first))
first = other;
Flags &f = flags (other);
if (other == -parent) {
conflicting = true; // conflicting scc
}
if (f.seen) {
continue; // also conflicting scc
}
f.seen = true;
analyzed.push_back (other);
} while (other != parent);
assert (!conflicting || first > 0);
vector todo;
if (conflicting) {
LOG ("conflicting scc simulating up at %d", parent);
todo.push_back (-parent);
} else
todo.push_back (first);
while (!todo.empty ()) {
const int next = todo.back ();
todo.pop_back ();
Watches &next_ws = watches (-next);
for (const auto &w : next_ws) {
if (!w.binary ())
continue;
const int child = w.blit;
if (!active (child))
continue;
if (!flags (child).seen)
continue;
DFS &child_dfs = dfs[vlit (child)];
if (child_dfs.parent)
continue;
child_dfs.parent = w.clause;
todo.push_back (child);
}
}
clear_analyzed_literals ();
}
int other, repr = parent;
#ifndef QUIET
int size = 0;
#endif
assert (!scc.empty ());
size_t j = scc.size ();
do {
assert (j > 0);
other = scc[--j];
if (other == -parent) {
LOG ("both %d and %d in one SCC", parent, -parent);
if (opts.lrat && !opts.lratexternal) {
Flags &f = flags (-parent);
f.seen = true;
analyzed.push_back (-parent);
decompose_analyze_binary_chain (dfs, parent);
for (auto p : mini_chain)
lrat_chain.push_back (p);
mini_chain.clear ();
}
assign_unit (parent);
if (opts.lrat && !opts.lratexternal) {
// bool ok = propagate (); // TODO
// differentiate between
propagate (); // normal usage and logging/debugging
// assert (!ok); // to avoid
// compiler warnings
}
learn_empty_clause ();
lrat_chain.clear ();
} else {
if (abs (other) < abs (repr))
repr = other;
#ifndef QUIET
size++;
#endif
}
} while (!unsat && other != parent);
if (unsat)
break;
LOG ("SCC of representative %d of size %d", repr, size);
do {
assert (!scc.empty ());
other = scc.back ();
scc.pop_back ();
dfs[vlit (other)].min = TRAVERSED;
if (frozen (other)) {
reprs[vlit (other)] = other;
continue;
}
reprs[vlit (other)] = repr;
if (other == repr)
continue;
substituted++;
LOG ("literal %d in SCC of %d", other, repr);
if (!opts.lrat || opts.lratexternal)
continue;
assert (mini_chain.empty ());
Flags &f = flags (repr);
f.seen = true;
analyzed.push_back (repr);
dfs_chains[vlit (other)] =
decompose_analyze_binary_clauses (dfs, other);
// reverse (dfs_chains[vlit (other)].begin (),
// dfs_chains[vlit (other)].end ());
clear_analyzed_literals ();
} while (other != parent);
#ifndef QUIET
if (size > 1)
non_trivial_sccs++;
#endif
} else {
// Current node 'parent' is in a non-trivial SCC but is not
// the entry point of the SCC in this depth first search, so
// keep it on the SCC stack until the entry point is reached.
parent_dfs.min = new_min;
}
} else { // pre-fix
dfs_idx++;
assert (dfs_idx < TRAVERSED);
parent_dfs.idx = parent_dfs.min = dfs_idx;
scc.push_back (parent);
LOG ("pre-fix work dfs search %d index %u", parent, dfs_idx);
// Now traverse all the children in the binary implication
// graph but keep 'parent' on the stack for 'post-fix' work.
for (const auto &w : ws) {
if (!w.binary ())
continue;
const int child = w.blit;
if (!active (child))
continue;
DFS &child_dfs = dfs[vlit (child)];
if (child_dfs.idx)
continue;
work.push_back (child);
}
}
}
}
}
}
erase_vector (work);
erase_vector (scc);
// delete [] dfs; need to postpone until after changing clauses...
// Only keep the representatives 'repr' mapping.
PHASE ("decompose", stats.decompositions,
"%d non-trivial sccs, %d substituted %.2f%%", non_trivial_sccs,
substituted, percent (substituted, before));
bool new_unit = false, new_binary_clause = false;
vector postponed_garbage;
// Now go over all clauses and find clause which contain literals that
// should be substituted by their representative.
size_t clauses_size = clauses.size ();
#ifndef QUIET
size_t garbage = 0, replaced = 0;
#endif
for (size_t i = 0; substituted && !unsat && i < clauses_size; i++) {
Clause *c = clauses[i];
if (c->garbage)
continue;
int j, size = c->size;
for (j = 0; j < size; j++) {
const int lit = c->literals[j];
if (reprs[vlit (lit)] != lit)
break;
}
if (j == size)
continue;
#ifndef QUIET
replaced++;
#endif
LOG (c, "first substituted literal %d in", substituted);
// Now copy the result to 'clause'. Substitute literals if they have a
// different representative. Skip duplicates and false literals. If a
// literal occurs in both phases or is assigned to true the clause is
// satisfied and can be marked as garbage.
assert (clause.empty ());
assert (lrat_chain.empty ());
assert (analyzed.empty ());
bool satisfied = false;
for (int k = 0; !satisfied && k < size; k++) {
const int lit = c->literals[k];
signed char tmp = val (lit);
if (tmp > 0)
satisfied = true;
else if (tmp < 0)
continue;
else {
const int other = reprs[vlit (lit)];
tmp = val (other);
if (tmp < 0)
continue;
else if (tmp > 0)
satisfied = true;
else {
tmp = marked (other);
if (tmp < 0)
satisfied = true;
else if (!tmp) {
mark (other);
clause.push_back (other);
}
}
}
}
// build lrat
if (opts.lrat && !opts.lratexternal) {
LOG ("building chain for not subsumed clause");
assert (lrat_chain.empty ());
assert (decomposed.empty ());
for (const auto lit : *c) { // build chain for each replaced literal
auto other = -lit;
if (val (other) > 0) {
if (marked_decompose (other))
continue;
mark_decomposed (other);
const unsigned uidx = vlit (other);
uint64_t id = unit_clauses[uidx];
assert (id);
lrat_chain.push_back (id);
continue;
}
assert (mini_chain.empty ());
for (auto p : dfs_chains[vlit (other)]) {
if (marked_decompose (other))
continue;
mark_decomposed (other);
int implied = p->literals[0];
implied = implied == other ? -p->literals[1] : -implied;
LOG ("ADDED %d -> %d (%" PRIu64 ")", implied, other, p->id);
other = implied;
mini_chain.push_back (p->id);
if (val (implied) <= 0)
continue;
if (marked_decompose (implied))
break;
mark_decomposed (implied);
// if (val (implied) == 0) continue;
const unsigned uidx = vlit (implied);
uint64_t id = unit_clauses[uidx];
assert (id);
mini_chain.push_back (id);
break;
}
for (auto p = mini_chain.rbegin (); p != mini_chain.rend (); p++)
lrat_chain.push_back (*p);
mini_chain.clear ();
}
// clear_analyzed_literals ();
clear_decomposed_literals ();
lrat_chain.push_back (c->id);
LOG (lrat_chain, "lrat_chain: ");
}
if (satisfied) {
LOG (c, "satisfied after substitution (postponed)");
postponed_garbage.push_back (c);
#ifndef QUIET
garbage++;
#endif
} else if (!clause.size ()) {
LOG ("learned empty clause during decompose");
learn_empty_clause ();
} else if (clause.size () == 1) {
LOG (c, "unit %d after substitution", clause[0]);
assign_unit (clause[0]);
mark_garbage (c);
new_unit = true;
#ifndef QUIET
garbage++;
#endif
} else if (c->literals[0] != clause[0] || c->literals[1] != clause[1]) {
LOG ("need new clause since at least one watched literal changed");
if (clause.size () == 2)
new_binary_clause = true;
size_t d_clause_idx = clauses.size ();
Clause *d = new_clause_as (c);
assert (clauses[d_clause_idx] == d);
clauses[d_clause_idx] = c;
clauses[i] = d;
mark_garbage (c);
#ifndef QUIET
garbage++;
#endif
} else {
LOG ("simply shrinking clause since watches did not change");
assert (c->size > 2);
if (!c->redundant)
mark_removed (c);
if (proof) {
if (opts.lrat && !opts.lratexternal)
proof->add_derived_clause (++clause_id, clause, lrat_chain);
else
proof->add_derived_clause (++clause_id, clause);
proof->delete_clause (c);
c->id = clause_id;
}
size_t l;
for (l = 2; l < clause.size (); l++)
c->literals[l] = clause[l];
int flushed = c->size - (int) l;
if (flushed) {
if (l == 2)
new_binary_clause = true;
LOG ("flushed %d literals", flushed);
(void) shrink_clause (c, l);
} else if (likely_to_be_kept_clause (c))
mark_added (c);
// we have assert (c->size > 2)
if (c->size == 2) { // cheaper to update only new binary clauses
update_watch_size (watches (c->literals[0]), c->literals[1], c);
update_watch_size (watches (c->literals[1]), c->literals[0], c);
}
LOG (c, "substituted");
}
while (!clause.empty ()) {
int lit = clause.back ();
clause.pop_back ();
assert (marked (lit) > 0);
unmark (lit);
}
lrat_chain.clear ();
}
if (!unsat && !postponed_garbage.empty ()) {
LOG ("now marking %zd postponed garbage clauses",
postponed_garbage.size ());
for (const auto &c : postponed_garbage)
mark_garbage (c);
}
erase_vector (postponed_garbage);
PHASE ("decompose", stats.decompositions,
"%zd clauses replaced %.2f%% producing %zd garbage clauses %.2f%%",
replaced, percent (replaced, clauses_size), garbage,
percent (garbage, replaced));
erase_vector (scc);
// Propagate found units.
if (!unsat && propagated < trail.size () && !propagate ()) {
LOG ("empty clause after propagating units from substitution");
learn_empty_clause ();
}
// Finally, mark substituted literals as such and push the equivalences of
// the substituted literals to their representative on the extension
// stack to fix an assignment during 'extend'.
//
// TODO instead of adding the clauses to the extension stack one could
// also just simply use the 'e2i' map as a union find data structure.
// This would avoid the need to restore these clauses.
for (auto idx : vars) {
if (unsat)
break;
if (!active (idx))
continue;
int other = reprs[vlit (idx)];
if (other == idx)
continue;
assert (!flags (other).eliminated ());
assert (!flags (other).substituted ());
if (!flags (other).fixed ())
mark_substituted (idx);
external->push_binary_clause_on_extension_stack (-idx, other);
external->push_binary_clause_on_extension_stack (idx, -other);
}
delete[] reprs;
delete[] dfs;
erase_vector (dfs_chains);
flush_all_occs_and_watches (); // particularly the 'blit's
bool success =
unsat || (substituted > 0 && (new_unit || new_binary_clause));
report ('d', !opts.reportall && !success);
STOP_SIMPLIFIER (decompose, DECOMP);
return success;
}
void Internal::decompose () {
for (int round = 1; round <= opts.decomposerounds; round++)
if (!decompose_round ())
break;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/decompose.hpp 0000664 0000000 0000000 00000001332 14501267155 0017146 0 ustar 00root root 0000000 0000000 #ifndef _decompose_hpp_INCLUDED
#define _decompose_hpp_INCLUDED
namespace CaDiCaL {
// This implements Tarjan's algorithm for decomposing the binary implication
// graph intro strongly connected components (SCCs). Literals in one SCC
// are equivalent and we replace them all by the literal with the smallest
// index in the SCC. These variables are marked 'substituted' and will be
// removed from all clauses. Their value will be fixed during 'extend'.
#define TRAVERSED UINT_MAX // mark completely traversed
struct DFS {
unsigned idx; // depth first search index
unsigned min; // minimum reachable index
Clause *parent; // for lrat
DFS () : idx (0), min (0), parent (0) {}
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/deduplicate.cpp 0000664 0000000 0000000 00000011432 14501267155 0017450 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
// Equivalent literal substitution in 'decompose' and shrinking in 'subsume'
// or 'vivify' might produce duplicated binary clauses. They can not be
// found in 'subsume' nor 'vivify' since we explicitly do not consider
// binary clauses as candidates to be shrunken or subsumed. They are
// detected here by a simple scan of watch lists and then marked as garbage.
// This is actually also quite fast.
// Further it might also be possible that two binary clauses can be resolved
// to produce a unit (we call it 'hyper unary resolution'). For example
// resolving the binary clauses '1 -2' and '1 2' produces the unit '1'.
// This could be found by probing in 'probe' unless '-1' also occurs in a
// binary clause (add the clause '-1 2' to those two clauses) in which case
// '1' as well as '2' both occur positively as well as negatively and none
// of them nor their negation is considered as probe
void Internal::mark_duplicated_binary_clauses_as_garbage () {
if (!opts.deduplicate)
return;
if (unsat)
return;
if (terminated_asynchronously ())
return;
START_SIMPLIFIER (deduplicate, DEDUP);
stats.deduplications++;
assert (!level);
assert (watching ());
vector stack; // To save marked literals and unmark them later.
int64_t subsumed = 0;
int64_t units = 0;
for (auto idx : vars) {
if (unsat)
break;
if (!active (idx))
continue;
int unit = 0;
for (int sign = -1; !unit && sign <= 1; sign += 2) {
const int lit = sign * idx; // Consider all literals.
assert (stack.empty ());
Watches &ws = watches (lit);
// We are removing references to garbage clause. Thus no 'auto'.
const const_watch_iterator end = ws.end ();
watch_iterator j = ws.begin ();
const_watch_iterator i;
for (i = j; !unit && i != end; i++) {
Watch w = *j++ = *i;
if (!w.binary ())
continue;
int other = w.blit;
const int tmp = marked (other);
Clause *c = w.clause;
if (tmp > 0) { // Found duplicated binary clause.
if (c->garbage) {
j--;
continue;
}
LOG (c, "found duplicated");
// The previous identical clause 'd' might be redundant and if the
// second clause 'c' is not (so irredundant), then we have to keep
// 'c' instead of 'd', thus we search for it and replace it.
if (!c->redundant) {
watch_iterator k;
for (k = ws.begin ();; k++) {
assert (k != i);
if (!k->binary ())
continue;
if (k->blit != other)
continue;
Clause *d = k->clause;
if (d->garbage)
continue;
c = d;
break;
}
*k = w;
}
LOG (c, "mark garbage duplicated");
stats.subsumed++;
stats.deduplicated++;
subsumed++;
mark_garbage (c);
j--;
} else if (tmp < 0) { // Hyper unary resolution.
LOG ("found %d %d and %d %d which produces unit %d", lit, -other,
lit, other, lit);
unit = lit;
if (opts.lrat && !opts.lratexternal) {
// taken from fradical
assert (lrat_chain.empty ());
lrat_chain.push_back (c->id);
// We've forgotten where the other binary clause is, so go find
// it again
for (watch_iterator k = ws.begin ();; k++) {
assert (k != i);
if (!k->binary ())
continue;
if (k->blit != -other)
continue;
lrat_chain.push_back (k->clause->id);
break;
}
}
j = ws.begin (); // Flush 'ws'.
units++;
} else {
if (c->garbage)
continue;
mark (other);
stack.push_back (other);
}
}
if (j == ws.begin ())
erase_vector (ws);
else if (j != end)
ws.resize (j - ws.begin ()); // Shrink watchers.
for (const auto &other : stack)
unmark (other);
stack.clear ();
}
// Propagation potentially messes up the watches and thus we can not
// propagate the unit immediately after finding it. Instead we break
// out of both loops and assign and propagate the unit here.
if (unit) {
stats.failed++;
stats.hyperunary++;
assign_unit (unit);
// lrat_chain.clear (); done in search_assign
if (!propagate ()) {
LOG ("empty clause after propagating unit");
learn_empty_clause ();
}
}
}
STOP_SIMPLIFIER (deduplicate, DEDUP);
report ('2', !opts.reportall && !(subsumed + units));
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/elim.cpp 0000664 0000000 0000000 00000102635 14501267155 0016121 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// Implements a variant of bounded variable elimination as originally
// described in our SAT'05 paper introducing 'SATeLite'. This is an
// inprocessing version, i.e., it is interleaved with search and triggers
// subsumption and strengthening, blocked and covered clause elimination
// during elimination rounds. It focuses only those variables which
// occurred in removed irredundant clauses since the last time an
// elimination round was run. By bounding the maximum resolvent size we can
// run each elimination round until completion. See the code of 'elim' for
// how elimination rounds are interleaved with blocked clause elimination
// and subsumption (which in turn also calls vivification and transitive
// reduction of the binary implication graph).
/*------------------------------------------------------------------------*/
inline double Internal::compute_elim_score (unsigned lit) {
assert (1 <= lit), assert (lit <= (unsigned) max_var);
const unsigned uidx = 2 * lit;
const double pos = internal->ntab[uidx];
const double neg = internal->ntab[uidx + 1];
if (!pos)
return -neg;
if (!neg)
return -pos;
double sum = 0, prod = 0;
if (opts.elimsum)
sum = opts.elimsum * (pos + neg);
if (opts.elimprod)
prod = opts.elimprod * (pos * neg);
return prod + sum;
}
/*------------------------------------------------------------------------*/
inline bool elim_more::operator() (unsigned a, unsigned b) {
const auto s = internal->compute_elim_score (a);
const auto t = internal->compute_elim_score (b);
if (s > t)
return true;
if (s < t)
return false;
return a > b;
}
/*------------------------------------------------------------------------*/
// Note that the new fast subsumption algorithm implemented in 'subsume'
// does not distinguish between irredundant and redundant clauses and is
// also run during search to strengthen and remove 'sticky' redundant
// clauses but also irredundant ones. So beside learned units during search
// or as consequence of other preprocessors, these subsumption rounds during
// search can remove (irredundant) clauses (and literals), which in turn
// might make new bounded variable elimination possible. This is tested
// in the 'bool eliminating ()' guard.
bool Internal::eliminating () {
if (!opts.elim)
return false;
if (!preprocessing && !opts.inprocessing)
return false;
if (preprocessing)
assert (lim.preprocessing);
// Respect (increasing) conflict limit.
//
if (lim.elim >= stats.conflicts)
return false;
// Wait until there are new units or new removed variables
// (in removed or shrunken irredundant clauses and thus marked).
//
if (last.elim.fixed < stats.all.fixed)
return true;
if (last.elim.marked < stats.mark.elim)
return true;
return false;
}
/*------------------------------------------------------------------------*/
// Update the global elimination schedule after adding or removing a clause.
void Internal::elim_update_added_clause (Eliminator &eliminator,
Clause *c) {
assert (!c->redundant);
ElimSchedule &schedule = eliminator.schedule;
for (const auto &lit : *c) {
if (!active (lit))
continue;
occs (lit).push_back (c);
if (frozen (lit))
continue;
noccs (lit)++;
const int idx = abs (lit);
if (schedule.contains (idx))
schedule.update (idx);
}
}
void Internal::elim_update_removed_lit (Eliminator &eliminator, int lit) {
if (!active (lit))
return;
if (frozen (lit))
return;
int64_t &score = noccs (lit);
assert (score > 0);
score--;
const int idx = abs (lit);
ElimSchedule &schedule = eliminator.schedule;
if (schedule.contains (idx))
schedule.update (idx);
else {
LOG ("rescheduling %d for elimination after removing clause", idx);
schedule.push_back (idx);
}
}
void Internal::elim_update_removed_clause (Eliminator &eliminator,
Clause *c, int except) {
assert (!c->redundant);
for (const auto &lit : *c) {
if (lit == except)
continue;
assert (lit != -except);
elim_update_removed_lit (eliminator, lit);
}
}
/*------------------------------------------------------------------------*/
// Since we do not have watches we have to do our own unit propagation
// during elimination as soon we find a unit clause. This finds new units
// and also marks clauses satisfied by those units as garbage immediately.
void Internal::elim_propagate (Eliminator &eliminator, int root) {
assert (val (root) > 0);
vector work;
size_t i = 0;
work.push_back (root);
while (i < work.size ()) {
int lit = work[i++];
LOG ("elimination propagation of %d", lit);
assert (val (lit) > 0);
const Occs &ns = occs (-lit);
for (const auto &c : ns) {
if (c->garbage)
continue;
int unit = 0, satisfied = 0;
for (const auto &other : *c) {
const signed char tmp = val (other);
if (tmp < 0)
continue;
if (tmp > 0) {
satisfied = other;
break;
}
if (unit)
unit = INT_MIN;
else
unit = other;
}
if (satisfied) {
LOG (c, "elimination propagation of %d finds %d satisfied", lit,
satisfied);
elim_update_removed_clause (eliminator, c, satisfied);
mark_garbage (c);
} else if (!unit) {
LOG ("empty clause during elimination propagation of %d", lit);
// need to set conflict = c for lrat
conflict = c;
learn_empty_clause ();
conflict = 0;
break;
} else if (unit != INT_MIN) {
LOG ("new unit %d during elimination propagation of %d", unit, lit);
build_chain_for_units (unit, c, 0);
assign_unit (unit);
work.push_back (unit);
}
}
if (unsat)
break;
const Occs &ps = occs (lit);
for (const auto &c : ps) {
if (c->garbage)
continue;
LOG (c, "elimination propagation of %d produces satisfied", lit);
elim_update_removed_clause (eliminator, c, lit);
mark_garbage (c);
}
}
}
/*------------------------------------------------------------------------*/
// On-the-fly self-subsuming resolution during variable elimination is due
// to HyoJung Han, Fabio Somenzi, SAT'09. Basically while resolving two
// clauses we test the resolvent to be smaller than one of the antecedents.
// If this is the case the pivot can be removed from the antecedent
// on-the-fly and the resolution can be skipped during elimination.
void Internal::elim_on_the_fly_self_subsumption (Eliminator &eliminator,
Clause *c, int pivot) {
LOG (c, "pivot %d on-the-fly self-subsuming resolution", pivot);
stats.elimotfstr++;
stats.strengthened++;
assert (clause.empty ());
for (const auto &lit : *c) {
if (lit == pivot)
continue;
const signed char tmp = val (lit);
assert (tmp <= 0);
if (tmp < 0)
continue;
clause.push_back (lit);
}
Clause *r = new_resolved_irredundant_clause ();
elim_update_added_clause (eliminator, r);
clause.clear ();
lrat_chain.clear ();
elim_update_removed_clause (eliminator, c, pivot);
mark_garbage (c);
}
/*------------------------------------------------------------------------*/
// Resolve two clauses on the pivot literal 'pivot', which is assumed to
// occur in opposite phases in 'c' and 'd'. The actual resolvent is stored
// in the temporary global 'clause' if it is not redundant. It is
// considered redundant if one of the clauses is already marked as garbage
// it is root level satisfied, the resolvent is empty, a unit, or produces a
// self-subsuming resolution, which results in the pivot to be removed from
// at least one of the antecedents.
// Note that current root level assignments are taken into account, i.e., by
// removing root level falsified literals. The function returns true if the
// resolvent is not redundant and for instance has to be taken into account
// during bounded variable elimination.
// Detected units are immediately assigned and in case the last argument is
// true also propagated eagerly in a elimination specific propagation
// routine, which not only finds units but also updates the schedule.
// When this function is called during computation of the number of
// non-trivial (or non-satisfied) resolvents we can eagerly propagate units.
// But during actually adding the resolvents this results in problems as we
// found one rare test case '../test/trace/reg0056.trace' (out of billions),
// where the pivot itself was assigned during such a propagation while
// adding resolvents and lead to pushing a clause to the reconstruction
// stack that later flipped the value of the pivot (while all other literals
// in that clause were unit implied too). Not pushing the pivot clauses to
// the reconstruction stack produced a wrong model too. Our fix is to only
// eagerly propagate during computation of the number of resolvents and
// otherwise delay propagation until the end of elimination (which is less
// precise regarding scheduling but very rarely happens).
bool Internal::resolve_clauses (Eliminator &eliminator, Clause *c,
int pivot, Clause *d,
const bool propagate_eagerly) {
assert (!c->redundant);
assert (!d->redundant);
stats.elimres++;
if (c->garbage || d->garbage)
return false;
if (c->size > d->size) {
pivot = -pivot;
swap (c, d);
}
assert (!level);
assert (clause.empty ());
int satisfied = 0; // Contains this satisfying literal.
int tautological = 0; // Clashing literal if tautological.
int s = 0; // Actual literals from 'c'.
int t = 0; // Actual literals from 'd'.
// First determine whether the first antecedent is satisfied, add its
// literals to 'clause' and mark them (except for 'pivot').
//
for (const auto &lit : *c) {
if (lit == pivot) {
s++;
continue;
}
assert (lit != -pivot);
const signed char tmp = val (lit);
if (tmp > 0) {
satisfied = lit;
break;
} else if (tmp < 0) {
if (!opts.lrat || opts.lratexternal)
continue;
Flags &f = flags (lit);
if (f.seen)
continue;
analyzed.push_back (lit);
f.seen = true;
const unsigned uidx = vlit (-lit);
uint64_t id = unit_clauses[uidx];
assert (id);
lrat_chain.push_back (id);
continue;
} else
mark (lit), clause.push_back (lit), s++;
}
if (satisfied) {
LOG (c, "satisfied by %d antecedent", satisfied);
elim_update_removed_clause (eliminator, c, satisfied);
mark_garbage (c);
clause.clear ();
lrat_chain.clear ();
clear_analyzed_literals ();
unmark (c);
return false;
}
// Then determine whether the second antecedent is satisfied, add its
// literal to 'clause' and check whether a clashing literal is found, such
// that the resolvent would be tautological.
//
for (const auto &lit : *d) {
if (lit == -pivot) {
t++;
continue;
}
assert (lit != pivot);
signed char tmp = val (lit);
if (tmp > 0) {
satisfied = lit;
break;
} else if (tmp < 0) {
if (!opts.lrat || opts.lratexternal)
continue;
Flags &f = flags (lit);
if (f.seen)
continue;
analyzed.push_back (lit);
f.seen = true;
const unsigned uidx = vlit (-lit);
uint64_t id = unit_clauses[uidx];
assert (id);
lrat_chain.push_back (id);
continue;
} else if ((tmp = marked (lit)) < 0) {
tautological = lit;
break;
} else if (!tmp)
clause.push_back (lit), t++;
else
assert (tmp > 0), t++;
}
clear_analyzed_literals ();
unmark (c);
const int64_t size = clause.size ();
if (opts.lrat && !opts.lratexternal) {
lrat_chain.push_back (d->id);
lrat_chain.push_back (c->id);
}
if (satisfied) {
LOG (d, "satisfied by %d antecedent", satisfied);
elim_update_removed_clause (eliminator, d, satisfied);
mark_garbage (d);
clause.clear ();
lrat_chain.clear ();
return false;
}
LOG (c, "first antecedent");
LOG (d, "second antecedent");
if (tautological) {
clause.clear ();
LOG ("resolvent tautological on %d", tautological);
lrat_chain.clear ();
return false;
}
if (!size) {
clause.clear ();
LOG ("empty resolvent");
// TODO: lrat?? c or d (or both) should be sufficient.
// -> also need all unit ids (for negated lits in c and d)
learn_empty_clause (); // already clears lrat_chain.
return false;
}
if (size == 1) {
int unit = clause[0];
LOG ("unit resolvent %d", unit);
clause.clear ();
// TODO: lrat, prob c + d
// -> also need all unit ids (for negated lits in c and d)
assign_unit (unit); // already clears lrat_chain.
if (propagate_eagerly)
elim_propagate (eliminator, unit);
return false;
}
LOG (clause, "resolvent");
assert (!opts.lrat || opts.lratexternal || !lrat_chain.empty ());
// Double self-subsuming resolution. The clauses 'c' and 'd' are
// identical except for the pivot which occurs in different phase. The
// resolvent subsumes both antecedents.
if (s > size && t > size) {
assert (s == size + 1);
assert (t == size + 1);
clause.clear ();
// TODO: lrat is c + d (+ eventual units)
elim_on_the_fly_self_subsumption (eliminator, c, pivot);
LOG (d, "double pivot %d on-the-fly self-subsuming resolution", -pivot);
stats.elimotfsub++;
stats.subsumed++;
elim_update_removed_clause (eliminator, d, -pivot);
mark_garbage (d);
return false;
}
// Single self-subsuming resolution: The pivot can be removed from 'c',
// which is implemented by adding a clause which is the same as 'c' but
// with 'pivot' removed and then marking 'c' as garbage.
if (s > size) {
assert (s == size + 1);
clause.clear ();
// TODO: lrat is c + d (+ eventual units) -> not 100% sure.
elim_on_the_fly_self_subsumption (eliminator, c, pivot);
return false;
}
// Same single self-subsuming resolution situation, but only for 'd'.
if (t > size) {
assert (t == size + 1);
clause.clear ();
// TODO: lrat is c + d (+ eventual units) -> same.
elim_on_the_fly_self_subsumption (eliminator, d, -pivot);
return false;
}
// TODO: either clear lrat_chain or check what we do from here on out.
// if propagate_eagerly is true we want to clear lrat_chain, else leave it
if (propagate_eagerly)
lrat_chain.clear ();
return true;
}
/*------------------------------------------------------------------------*/
// Check whether the number of non-tautological resolvents on 'pivot' is
// smaller or equal to the number of clauses with 'pivot' or '-pivot'. This
// is the main criteria of bounded variable elimination. As a side effect
// it flushes garbage clauses with that variable, sorts its occurrence lists
// (smallest clauses first) and also negates pivot if it has more positive
// than negative occurrences.
bool Internal::elim_resolvents_are_bounded (Eliminator &eliminator,
int pivot) {
const bool substitute = !eliminator.gates.empty ();
if (substitute)
LOG ("trying to substitute %d", pivot);
stats.elimtried++;
assert (!unsat);
assert (active (pivot));
const Occs &ps = occs (pivot);
const Occs &ns = occs (-pivot);
const int64_t pos = ps.size ();
const int64_t neg = ns.size ();
if (!pos || !neg)
return lim.elimbound >= 0;
const int64_t bound = pos + neg + lim.elimbound;
LOG ("checking number resolvents on %d bounded by "
"%" PRId64 " = %" PRId64 " + %" PRId64 " + %" PRId64,
pivot, bound, pos, neg, lim.elimbound);
// Try all resolutions between a positive occurrence (outer loop) of
// 'pivot' and a negative occurrence of 'pivot' (inner loop) as long the
// bound on non-tautological resolvents is not hit and the size of the
// generated resolvents does not exceed the resolvent clause size limit.
int64_t resolvents = 0; // Non-tautological resolvents.
for (const auto &c : ps) {
assert (!c->redundant);
if (c->garbage)
continue;
for (const auto &d : ns) {
assert (!d->redundant);
if (d->garbage)
continue;
if (substitute && c->gate == d->gate)
continue;
stats.elimrestried++;
if (resolve_clauses (eliminator, c, pivot, d, true)) {
resolvents++;
int size = clause.size ();
clause.clear ();
LOG ("now at least %" PRId64
" non-tautological resolvents on pivot %d",
resolvents, pivot);
if (size > opts.elimclslim) {
LOG ("resolvent size %d too big after %" PRId64
" resolvents on %d",
size, resolvents, pivot);
return false;
}
if (resolvents > bound) {
LOG ("too many non-tautological resolvents on %d", pivot);
return false;
}
} else if (unsat)
return false;
else if (val (pivot))
return false;
}
}
LOG ("need %" PRId64 " <= %" PRId64 " non-tautological resolvents",
resolvents, bound);
return true;
}
/*------------------------------------------------------------------------*/
// Add all resolvents on 'pivot' and connect them.
inline void Internal::elim_add_resolvents (Eliminator &eliminator,
int pivot) {
const bool substitute = !eliminator.gates.empty ();
if (substitute) {
LOG ("substituting pivot %d by resolving with %zd gate clauses", pivot,
eliminator.gates.size ());
stats.elimsubst++;
}
LOG ("adding all resolvents on %d", pivot);
assert (!val (pivot));
assert (!flags (pivot).eliminated ());
const Occs &ps = occs (pivot);
const Occs &ns = occs (-pivot);
#ifdef LOGGING
int64_t resolvents = 0;
#endif
for (auto &c : ps) {
if (unsat)
break;
if (c->garbage)
continue;
for (auto &d : ns) {
if (unsat)
break;
if (d->garbage)
continue;
if (substitute && c->gate == d->gate)
continue;
if (!resolve_clauses (eliminator, c, pivot, d, false))
continue;
assert (!opts.lrat || opts.lratexternal || !lrat_chain.empty ());
Clause *r = new_resolved_irredundant_clause ();
elim_update_added_clause (eliminator, r);
eliminator.enqueue (r);
lrat_chain.clear ();
clause.clear ();
#ifdef LOGGING
resolvents++;
#endif
}
}
LOG ("added %" PRId64 " resolvents to eliminate %d", resolvents, pivot);
}
/*------------------------------------------------------------------------*/
// Remove clauses with 'pivot' and '-pivot' by marking them as garbage and
// push them on the extension stack.
void Internal::mark_eliminated_clauses_as_garbage (Eliminator &eliminator,
int pivot) {
assert (!unsat);
LOG ("marking irredundant clauses with %d as garbage", pivot);
const int64_t substitute = eliminator.gates.size ();
if (substitute)
LOG ("pushing %" PRId64 " gate clauses on extension stack", substitute);
#ifndef NDEBUG
int64_t pushed = 0;
#endif
Occs &ps = occs (pivot);
for (const auto &c : ps) {
if (c->garbage)
continue;
mark_garbage (c);
assert (!c->redundant);
if (!substitute || c->gate) {
external->push_clause_on_extension_stack (c, pivot);
#ifndef NDEBUG
pushed++;
#endif
}
elim_update_removed_clause (eliminator, c, pivot);
}
erase_occs (ps);
LOG ("marking irredundant clauses with %d as garbage", -pivot);
Occs &ns = occs (-pivot);
for (const auto &d : ns) {
if (d->garbage)
continue;
mark_garbage (d);
assert (!d->redundant);
if (!substitute || d->gate) {
external->push_clause_on_extension_stack (d, -pivot);
#ifndef NDEBUG
pushed++;
#endif
}
elim_update_removed_clause (eliminator, d, -pivot);
}
erase_occs (ns);
if (substitute)
assert (pushed <= substitute);
// Unfortunately, we can not use the trick by Niklas Soerensson anymore,
// which avoids saving all clauses on the extension stack. This would
// break our new incremental 'restore' logic.
}
/*------------------------------------------------------------------------*/
// Try to eliminate 'pivot' by bounded variable elimination.
void Internal::try_to_eliminate_variable (Eliminator &eliminator,
int pivot) {
if (!active (pivot))
return;
assert (!frozen (pivot));
// First flush garbage clauses.
//
int64_t pos = flush_occs (pivot);
int64_t neg = flush_occs (-pivot);
if (pos > neg) {
pivot = -pivot;
swap (pos, neg);
}
LOG ("pivot %d occurs positively %" PRId64
" times and negatively %" PRId64 " times",
pivot, pos, neg);
assert (!eliminator.schedule.contains (abs (pivot)));
assert (pos <= neg);
if (pos && neg > opts.elimocclim) {
LOG ("too many occurrences thus not eliminated %d", pivot);
assert (!eliminator.schedule.contains (abs (pivot)));
return;
}
LOG ("trying to eliminate %d", pivot);
assert (!flags (pivot).eliminated ());
// Sort occurrence lists, such that shorter clauses come first.
Occs &ps = occs (pivot);
stable_sort (ps.begin (), ps.end (), clause_smaller_size ());
Occs &ns = occs (-pivot);
stable_sort (ns.begin (), ns.end (), clause_smaller_size ());
if (pos)
find_gate_clauses (eliminator, pivot);
if (!unsat && !val (pivot)) {
if (elim_resolvents_are_bounded (eliminator, pivot)) {
LOG ("number of resolvents on %d are bounded", pivot);
elim_add_resolvents (eliminator, pivot);
if (!unsat)
mark_eliminated_clauses_as_garbage (eliminator, pivot);
if (active (pivot))
mark_eliminated (pivot);
} else
LOG ("too many resolvents on %d so not eliminated", pivot);
}
unmark_gate_clauses (eliminator);
elim_backward_clauses (eliminator);
}
/*------------------------------------------------------------------------*/
void Internal::
mark_redundant_clauses_with_eliminated_variables_as_garbage () {
for (const auto &c : clauses) {
if (c->garbage || !c->redundant)
continue;
bool clean = true;
for (const auto &lit : *c) {
Flags &f = flags (lit);
if (f.eliminated ()) {
clean = false;
break;
}
if (f.pure ()) {
clean = false;
break;
}
}
if (!clean)
mark_garbage (c);
}
}
/*------------------------------------------------------------------------*/
// This function performs one round of bounded variable elimination and
// returns the number of eliminated variables. The additional result
// 'completed' is true if this elimination round ran to completion (all
// variables have been tried). Otherwise it was asynchronously terminated
// or the resolution limit was hit.
int Internal::elim_round (bool &completed) {
assert (opts.elim);
assert (!unsat);
START_SIMPLIFIER (elim, ELIM);
stats.elimrounds++;
last.elim.marked = stats.mark.elim;
assert (!level);
int64_t resolution_limit;
if (opts.elimlimited) {
int64_t delta = stats.propagations.search;
delta *= 1e-3 * opts.elimreleff;
if (delta < opts.elimineff)
delta = opts.elimineff;
if (delta > opts.elimaxeff)
delta = opts.elimaxeff;
delta = max (delta, (int64_t) 2l * active ());
PHASE ("elim-round", stats.elimrounds,
"limit of %" PRId64 " resolutions", delta);
resolution_limit = stats.elimres + delta;
} else {
PHASE ("elim-round", stats.elimrounds, "resolutions unlimited");
resolution_limit = LONG_MAX;
}
init_noccs ();
// First compute the number of occurrences of each literal and at the same
// time mark satisfied clauses and update 'elim' flags of variables in
// clauses with root level assigned literals (both false and true).
//
for (const auto &c : clauses) {
if (c->garbage || c->redundant)
continue;
bool satisfied = false, falsified = false;
for (const auto &lit : *c) {
const signed char tmp = val (lit);
if (tmp > 0)
satisfied = true;
else if (tmp < 0)
falsified = true;
else
assert (active (lit));
}
if (satisfied)
mark_garbage (c); // forces more precise counts
else {
for (const auto &lit : *c) {
if (!active (lit))
continue;
if (falsified)
mark_elim (lit); // simulate unit propagation
noccs (lit)++;
}
}
}
init_occs ();
Eliminator eliminator (this);
ElimSchedule &schedule = eliminator.schedule;
// Now find elimination candidates which occurred in clauses removed since
// the last time we ran bounded variable elimination, which in turned
// triggered their 'elim' bit to be set.
//
for (auto idx : vars) {
if (!active (idx))
continue;
if (frozen (idx))
continue;
if (!flags (idx).elim)
continue;
flags (idx).elim = false;
LOG ("scheduling %d for elimination initially", idx);
schedule.push_back (idx);
}
schedule.shrink ();
#ifndef QUIET
int64_t scheduled = schedule.size ();
#endif
PHASE ("elim-round", stats.elimrounds,
"scheduled %" PRId64 " variables %.0f%% for elimination",
scheduled, percent (scheduled, active ()));
// Connect irredundant clauses.
//
for (const auto &c : clauses)
if (!c->garbage && !c->redundant)
for (const auto &lit : *c)
if (active (lit))
occs (lit).push_back (c);
#ifndef QUIET
const int64_t old_resolutions = stats.elimres;
#endif
const int old_eliminated = stats.all.eliminated;
const int old_fixed = stats.all.fixed;
// Limit on garbage literals during variable elimination. If the limit is
// hit a garbage collection is performed.
//
const int64_t garbage_limit = (2 * stats.irrlits / 3) + (1 << 20);
// Main loops tries to eliminate variables according to the schedule. The
// schedule is updated dynamically and variables are potentially
// rescheduled to be tried again if they occur in a removed clause.
//
#ifndef QUIET
int64_t tried = 0;
#endif
while (!unsat && !terminated_asynchronously () &&
stats.elimres <= resolution_limit && !schedule.empty ()) {
int idx = schedule.front ();
schedule.pop_front ();
flags (idx).elim = false;
try_to_eliminate_variable (eliminator, idx);
#ifndef QUIET
tried++;
#endif
if (stats.garbage.literals <= garbage_limit)
continue;
mark_redundant_clauses_with_eliminated_variables_as_garbage ();
garbage_collection ();
}
// If the schedule is empty all variables have been tried (even
// rescheduled ones). Otherwise asynchronous termination happened or we
// ran into the resolution limit (or derived unsatisfiability).
//
completed = !schedule.size ();
PHASE ("elim-round", stats.elimrounds,
"tried to eliminate %" PRId64 " variables %.0f%% (%zd remain)",
tried, percent (tried, scheduled), schedule.size ());
schedule.erase ();
// Collect potential literal clause instantiation pairs, which needs full
// occurrence lists and thus we have it here before resetting them.
//
Instantiator instantiator;
if (!unsat && !terminated_asynchronously () && opts.instantiate)
collect_instantiation_candidates (instantiator);
reset_occs ();
reset_noccs ();
// Mark all redundant clauses with eliminated variables as garbage.
//
if (!unsat)
mark_redundant_clauses_with_eliminated_variables_as_garbage ();
int eliminated = stats.all.eliminated - old_eliminated;
#ifndef QUIET
int64_t resolutions = stats.elimres - old_resolutions;
PHASE ("elim-round", stats.elimrounds,
"eliminated %d variables %.0f%% in %" PRId64 " resolutions",
eliminated, percent (eliminated, scheduled), resolutions);
#endif
last.elim.subsumephases = stats.subsumephases;
const int units = stats.all.fixed - old_fixed;
report ('e', !opts.reportall && !(eliminated + units));
STOP_SIMPLIFIER (elim, ELIM);
if (!unsat && !terminated_asynchronously () &&
instantiator) // Do we have candidate pairs?
instantiate (instantiator);
return eliminated; // non-zero if successful
}
/*------------------------------------------------------------------------*/
// Increase elimination bound (additional clauses allowed during variable
// elimination), which is triggered if elimination with last bound completed
// (including no new subsumptions). This was pioneered by GlueMiniSAT in
// the SAT Race 2015 and then picked up Chanseok Oh in his COMinisatPS
// solver, which in turn is used in the Maple series of SAT solvers.
// The bound is no increased if the maximum bound is reached.
void Internal::increase_elimination_bound () {
if (lim.elimbound >= opts.elimboundmax)
return;
if (lim.elimbound < 0)
lim.elimbound = 0;
else if (!lim.elimbound)
lim.elimbound = 1;
else
lim.elimbound *= 2;
if (lim.elimbound > opts.elimboundmax)
lim.elimbound = opts.elimboundmax;
PHASE ("elim-phase", stats.elimphases,
"new elimination bound %" PRId64 "", lim.elimbound);
// Now reschedule all active variables for elimination again.
//
#ifdef LOGGING
int count = 0;
#endif
for (auto idx : vars) {
if (!active (idx))
continue;
if (flags (idx).elim)
continue;
mark_elim (idx);
#ifdef LOGGING
count++;
#endif
}
LOG ("marked %d variables as elimination candidates", count);
report ('^');
}
/*------------------------------------------------------------------------*/
void Internal::elim (bool update_limits) {
if (unsat)
return;
if (level)
backtrack ();
if (!propagate ()) {
learn_empty_clause ();
return;
}
stats.elimphases++;
PHASE ("elim-phase", stats.elimphases,
"starting at most %d elimination rounds", opts.elimrounds);
#ifndef QUIET
int old_active_variables = active ();
int old_eliminated = stats.all.eliminated;
#endif
// Make sure there was a complete subsumption phase since last
// elimination including vivification etc.
//
if (last.elim.subsumephases == stats.subsumephases)
subsume (update_limits);
reset_watches (); // saves lots of memory
// Alternate one round of bounded variable elimination ('elim_round') and
// subsumption ('subsume_round'), blocked ('block') and covered clause
// elimination ('cover') until nothing changes, or the round limit is hit.
// The loop also aborts early if no variable could be eliminated, the
// empty clause is resolved, it is asynchronously terminated or a
// resolution limit is hit.
// This variable determines whether the whole loop of this bounded
// variable elimination phase ('elim') ran until completion. This
// potentially triggers an incremental increase of the elimination bound.
//
bool phase_complete = false;
int round = 1;
while (!unsat && !phase_complete && !terminated_asynchronously ()) {
bool round_complete;
#ifndef QUIET
int eliminated =
#endif
elim_round (round_complete);
if (!round_complete) {
PHASE ("elim-phase", stats.elimphases, "last round %d incomplete %s",
round, eliminated ? "but successful" : "and unsuccessful");
assert (!phase_complete);
break;
}
if (round++ >= opts.elimrounds) {
PHASE ("elim-phase", stats.elimphases, "round limit %d hit (%s)",
round - 1,
eliminated ? "though last round successful"
: "last round unsuccessful anyhow");
assert (!phase_complete);
break;
}
// Prioritize 'subsumption' over blocked and covered clause elimination.
if (subsume_round ())
continue;
if (block ())
continue;
if (cover ())
continue;
// Was not able to generate new variable elimination candidates after
// variable elimination round, neither through subsumption, nor blocked,
// nor covered clause elimination.
//
PHASE ("elim-phase", stats.elimphases,
"no new variable elimination candidates");
assert (round_complete);
phase_complete = true;
}
if (phase_complete) {
stats.elimcompleted++;
PHASE ("elim-phase", stats.elimphases,
"fully completed elimination %" PRId64
" at elimination bound %" PRId64 "",
stats.elimcompleted, lim.elimbound);
} else {
PHASE ("elim-phase", stats.elimphases,
"incomplete elimination %" PRId64
" at elimination bound %" PRId64 "",
stats.elimcompleted + 1, lim.elimbound);
}
init_watches ();
connect_watches ();
if (unsat)
LOG ("elimination derived empty clause");
else if (propagated < trail.size ()) {
LOG ("elimination produced %zd units",
(size_t) (trail.size () - propagated));
if (!propagate ()) {
LOG ("propagating units after elimination results in empty clause");
learn_empty_clause ();
}
}
// If we ran variable elimination until completion we increase the
// variable elimination bound and reschedule elimination of all variables.
//
if (phase_complete)
increase_elimination_bound ();
#ifndef QUIET
int eliminated = stats.all.eliminated - old_eliminated;
PHASE ("elim-phase", stats.elimphases, "eliminated %d variables %.2f%%",
eliminated, percent (eliminated, old_active_variables));
#endif
if (!update_limits)
return;
int64_t delta = scale (opts.elimint * (stats.elimphases + 1));
lim.elim = stats.conflicts + delta;
PHASE ("elim-phase", stats.elimphases,
"new limit at %" PRId64 " conflicts after %" PRId64 " conflicts",
lim.elim, delta);
last.elim.fixed = stats.all.fixed;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/elim.hpp 0000664 0000000 0000000 00000001204 14501267155 0016114 0 ustar 00root root 0000000 0000000 #ifndef _elim_hpp_INCLUDED
#define _elim_hpp_INCLUDED
#include "heap.hpp" // Alphabetically after 'elim.hpp'.
namespace CaDiCaL {
struct Internal;
struct elim_more {
Internal *internal;
elim_more (Internal *i) : internal (i) {}
bool operator() (unsigned a, unsigned b);
};
typedef heap ElimSchedule;
struct Eliminator {
Internal *internal;
ElimSchedule schedule;
Eliminator (Internal *i) : internal (i), schedule (elim_more (i)) {}
~Eliminator ();
queue backward;
Clause *dequeue ();
void enqueue (Clause *);
vector gates;
vector marked;
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/ema.cpp 0000664 0000000 0000000 00000006465 14501267155 0015741 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
// Updating an exponential moving average is placed here since we want to
// log both updates and phases of initialization, thus need 'LOG'.
//
// We now use initialization bias correction as in the ADAM method
// [KingmaBa-ICLR'15] instead of our ad-hoc initialization method used
// before. Our old variant used exponentially decreasing alphas:
//
// 1,
// 1/2, 1/2,
// 1/4, 1/4, 1/4, 1/4
// 1/8, 1/8, 1/8, 1/8, 1/8, 1/8, 1/8, 1/8,
// ...
// 2^-n, ..., 2^-n 'n' times
// alpha, alpha, ... now 'alpha' forever.
//
// where 2^-n is the smallest negative power of two above 'alpha'
//
// This old method is better than the initializations described in our
// [BiereFroehlich-POS'15] paper and actually faster than the ADAM method,
// but less precise. We consider this old method obsolete now but it
// could still be useful for implementations relying on integers instead
// of floating points because it only needs shifts and integer arithmetic.
//
// Our new method for unbiased initialization of the exponential averages
// works as follows. First the biased moving average is computed as usual.
// Note that (as already before) we use the simpler equation
//
// new_biased = old_biased + alpha * (y - old_biased);
//
// which in principle (and thus easy to remember) can be implemented as
//
// biased += alpha * (y - biased);
//
// The original formulation in the ADAM paper (with 'alpha = 1 - beta') is
//
// new_biased = beta * old_biased + (1 - beta) * y
//
// To show that these are equivalent (modulo floating point issues)
// consider the following equivalent expressions:
//
// old_biased + alpha * (y - old_biased)
// old_biased + alpha * y - alpha * old_biased
// (1 - alpha) * old_biased + alpha * y
// beta * old_biased + (1 - beta) * y
//
// The real new idea taken from the ADAM paper is however to fix the biased
// moving average with a correction term '1.0 / (1.0 - pow (beta, updated))'
// by multiplication to obtain an unbiased moving average (called simply
// 'value' in our 'code'). In order to avoid computing 'pow' every time, we
// use 'exp' which is multiplied in every update with 'beta'.
void EMA::update (Internal *internal, double y, const char *name) {
#ifdef LOGGING
updated++;
const double old_value = value;
#endif
const double old_biased = biased;
const double delta = y - old_biased;
const double scaled_delta = alpha * delta;
const double new_biased = old_biased + scaled_delta;
LOG ("update %" PRIu64 " of biased %s EMA %g with %g (delta %g) "
"yields %g (scaled delta %g)",
updated, name, old_biased, y, delta, new_biased, scaled_delta);
biased = new_biased;
const double old_exp = exp;
double new_exp, div, new_value;
if (old_exp) {
new_exp = old_exp * beta;
assert (new_exp < 1);
exp = new_exp;
div = 1 - new_exp;
assert (div > 0);
new_value = new_biased / div;
} else {
new_value = new_biased;
#ifdef LOGGING
new_exp = 0;
div = 1;
#endif
}
value = new_value;
LOG ("update %" PRIu64 " of corrected %s EMA %g with %g (delta %g) "
"yields %g (exponent %g, divisor %g)",
updated, name, old_value, y, delta, new_value, new_exp, div);
#ifndef LOGGING
(void) internal;
(void) name;
#endif
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/ema.hpp 0000664 0000000 0000000 00000003053 14501267155 0015734 0 ustar 00root root 0000000 0000000 #ifndef _ema_hpp_INCLUDED
#define _ema_hpp_INCLUDED
namespace CaDiCaL {
struct Internal;
// This is a more complex generic exponential moving average class to
// support more robust initialization (see comments in the 'update'
// implementation).
struct EMA {
#ifdef LOGGING
uint64_t updated;
#endif
double value; // unbiased (corrected) moving average
double biased; // biased initialized moving average
double alpha; // input scaling with 'alpha = 1 - beta'
double beta; // decay of 'biased' with 'beta = 1 - alpha'
double exp; // 'exp = pow (beta, updated)'
EMA ()
:
#ifdef LOGGING
updated (0),
#endif
value (0), biased (0), alpha (0), beta (0), exp (0) {
}
EMA (double a)
:
#ifdef LOGGING
updated (0),
#endif
value (0), biased (0), alpha (a), beta (1 - a), exp (!!beta) {
assert (beta >= 0);
}
operator double () const { return value; }
void update (Internal *, double y, const char *name);
};
} // namespace CaDiCaL
/*------------------------------------------------------------------------*/
// Compact average update and initialization macros for better logging.
#define UPDATE_AVERAGE(A, Y) \
do { \
A.update (internal, (Y), #A); \
} while (0)
#define INIT_EMA(E, WINDOW) \
do { \
assert ((WINDOW) >= 1); \
double ALPHA = 1.0 / (double) (WINDOW); \
E = EMA (ALPHA); \
LOG ("init " #E " EMA target alpha %g window %d", ALPHA, \
(int) WINDOW); \
} while (0)
/*------------------------------------------------------------------------*/
#endif
cadical-rel-1.7.4/src/extend.cpp 0000664 0000000 0000000 00000014740 14501267155 0016461 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
void External::push_zero_on_extension_stack () {
extension.push_back (0);
LOG ("pushing 0 on extension stack");
}
void External::push_clause_literal_on_extension_stack (int ilit) {
assert (ilit);
const int elit = internal->externalize (ilit);
assert (elit);
extension.push_back (elit);
LOG ("pushing clause literal %d on extension stack (internal %d)", elit,
ilit);
}
void External::push_witness_literal_on_extension_stack (int ilit) {
assert (ilit);
const int elit = internal->externalize (ilit);
assert (elit);
extension.push_back (elit);
LOG ("pushing witness literal %d on extension stack (internal %d)", elit,
ilit);
if (marked (witness, elit))
return;
LOG ("marking witness %d", elit);
mark (witness, elit);
}
// The extension stack allows to reconstruct a satisfying assignment for the
// original formula after removing eliminated clauses. This was pioneered
// by Niklas Soerensson in MiniSAT and for instance is described in our
// inprocessing paper, published at IJCAR'12. This first function adds a
// clause to this stack. First the blocking or eliminated literal is added,
// and then the rest of the clause.
void External::push_clause_on_extension_stack (Clause *c) {
internal->stats.weakened++;
internal->stats.weakenedlen += c->size;
push_zero_on_extension_stack ();
for (const auto &lit : *c)
push_clause_literal_on_extension_stack (lit);
}
void External::push_clause_on_extension_stack (Clause *c, int pivot) {
push_zero_on_extension_stack ();
push_witness_literal_on_extension_stack (pivot);
push_clause_on_extension_stack (c);
}
void External::push_binary_clause_on_extension_stack (int pivot,
int other) {
internal->stats.weakened++;
internal->stats.weakenedlen += 2;
push_zero_on_extension_stack ();
push_witness_literal_on_extension_stack (pivot);
push_zero_on_extension_stack ();
push_clause_literal_on_extension_stack (pivot);
push_clause_literal_on_extension_stack (other);
}
/*------------------------------------------------------------------------*/
void External::push_external_clause_and_witness_on_extension_stack (
const vector &c, const vector &w) {
extension.push_back (0);
for (const auto &elit : w) {
assert (elit != INT_MIN);
init (abs (elit));
extension.push_back (elit);
mark (witness, elit);
}
extension.push_back (0);
for (const auto &elit : c) {
assert (elit != INT_MIN);
init (abs (elit));
extension.push_back (elit);
}
}
/*------------------------------------------------------------------------*/
// This is the actual extension process. It goes backward over the clauses
// on the extension stack and flips the assignment of one of the blocking
// literals in the conditional autarky stored before the clause. In the
// original algorithm for witness construction for variable elimination and
// blocked clause removal the conditional autarky consists of a single
// literal from the removed clause, while in general the autarky witness can
// contain an arbitrary set of literals. We are using the more general
// witness reconstruction here which for instance would also work for
// super-blocked or set-blocked clauses.
void External::extend () {
assert (!extended);
START (extend);
internal->stats.extensions++;
PHASE ("extend", internal->stats.extensions,
"mapping internal %d assignments to %d assignments",
internal->max_var, max_var);
#ifndef QUIET
int64_t updated = 0;
#endif
for (unsigned i = 1; i <= (unsigned) max_var; i++) {
const int ilit = e2i[i];
if (!ilit)
continue;
if (i >= vals.size ())
vals.resize (i + 1, false);
vals[i] = (internal->val (ilit) > 0);
#ifndef QUIET
updated++;
#endif
}
PHASE ("extend", internal->stats.extensions,
"updated %" PRId64 " external assignments", updated);
PHASE ("extend", internal->stats.extensions,
"extending through extension stack of size %zd",
extension.size ());
const auto begin = extension.begin ();
auto i = extension.end ();
#ifndef QUIET
int64_t flipped = 0;
#endif
while (i != begin) {
bool satisfied = false;
int lit;
assert (i != begin);
while ((lit = *--i)) {
if (satisfied)
continue;
if (ival (lit) > 0)
satisfied = true;
assert (i != begin);
}
assert (i != begin);
if (satisfied)
while (*--i)
assert (i != begin);
else {
while ((lit = *--i)) {
const int tmp = ival (lit); // not 'signed char'!!!
if (tmp < 0) {
LOG ("flipping blocking literal %d", lit);
assert (lit);
assert (lit != INT_MIN);
size_t idx = abs (lit);
if (idx >= vals.size ())
vals.resize (idx + 1, false);
vals[idx] = !vals[idx];
internal->stats.extended++;
#ifndef QUIET
flipped++;
#endif
}
assert (i != begin);
}
}
}
PHASE ("extend", internal->stats.extensions,
"flipped %" PRId64 " literals during extension", flipped);
extended = true;
LOG ("extended");
STOP (extend);
}
/*------------------------------------------------------------------------*/
bool External::traverse_witnesses_backward (WitnessIterator &it) {
if (internal->unsat)
return true;
vector clause, witness;
const auto begin = extension.begin ();
auto i = extension.end ();
while (i != begin) {
int lit;
while ((lit = *--i))
clause.push_back (lit);
while ((lit = *--i))
witness.push_back (lit);
reverse (clause.begin (), clause.end ());
reverse (witness.begin (), witness.end ());
if (!it.witness (clause, witness))
return false;
clause.clear ();
witness.clear ();
}
return true;
}
bool External::traverse_witnesses_forward (WitnessIterator &it) {
if (internal->unsat)
return true;
vector clause, witness;
const auto end = extension.end ();
auto i = extension.begin ();
if (i != end) {
int lit = *i++;
do {
assert (!lit), (void) lit;
while ((lit = *i++))
witness.push_back (lit);
assert (!lit);
assert (i != end);
while (i != end && (lit = *i++))
clause.push_back (lit);
if (!it.witness (clause, witness))
return false;
clause.clear ();
witness.clear ();
} while (i != end);
}
return true;
}
/*------------------------------------------------------------------------*/
} // namespace CaDiCaL
cadical-rel-1.7.4/src/external.cpp 0000664 0000000 0000000 00000057700 14501267155 0017017 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
External::External (Internal *i)
: internal (i), max_var (0), vsize (0), extended (false),
terminator (0), learner (0), propagator (0), solution (0),
vars (max_var) {
assert (internal);
assert (!internal->external);
internal->external = this;
}
External::~External () {
if (solution)
delete[] solution;
}
void External::enlarge (int new_max_var) {
assert (!extended);
size_t new_vsize = vsize ? 2 * vsize : 1 + (size_t) new_max_var;
while (new_vsize <= (size_t) new_max_var)
new_vsize *= 2;
LOG ("enlarge external size from %zd to new size %zd", vsize, new_vsize);
vsize = new_vsize;
}
void External::init (int new_max_var) {
assert (!extended);
if (new_max_var <= max_var)
return;
int new_vars = new_max_var - max_var;
int old_internal_max_var = internal->max_var;
int new_internal_max_var = old_internal_max_var + new_vars;
internal->init_vars (new_internal_max_var);
if ((size_t) new_max_var >= vsize)
enlarge (new_max_var);
LOG ("initialized %d external variables", new_vars);
if (!max_var) {
assert (e2i.empty ());
e2i.push_back (0);
ext_units.push_back (0);
ext_units.push_back (0);
ext_flags.push_back (0);
assert (internal->i2e.empty ());
internal->i2e.push_back (0);
} else {
assert (e2i.size () == (size_t) max_var + 1);
assert (internal->i2e.size () == (size_t) old_internal_max_var + 1);
}
unsigned iidx = old_internal_max_var + 1, eidx;
for (eidx = max_var + 1u; eidx <= (unsigned) new_max_var;
eidx++, iidx++) {
LOG ("mapping external %u to internal %u", eidx, iidx);
assert (e2i.size () == eidx);
e2i.push_back (iidx);
ext_units.push_back (0);
ext_units.push_back (0);
ext_flags.push_back (0);
internal->i2e.push_back (eidx);
assert (internal->i2e[iidx] == (int) eidx);
assert (e2i[eidx] == (int) iidx);
}
if (new_max_var >= (int64_t) is_observed.size ())
is_observed.resize (1 + (size_t) new_max_var, false);
if (internal->opts.checkfrozen)
if (new_max_var >= (int64_t) moltentab.size ())
moltentab.resize (1 + (size_t) new_max_var, false);
assert (iidx == (size_t) new_internal_max_var + 1);
assert (eidx == (size_t) new_max_var + 1);
assert (ext_units.size () == (size_t) new_max_var * 2 + 2);
max_var = new_max_var;
}
/*------------------------------------------------------------------------*/
void External::reset_assumptions () {
assumptions.clear ();
internal->reset_assumptions ();
}
void External::reset_constraint () {
constraint.clear ();
internal->reset_constraint ();
}
void External::reset_extended () {
if (!extended)
return;
LOG ("reset extended");
extended = false;
}
void External::reset_limits () { internal->reset_limits (); }
/*------------------------------------------------------------------------*/
int External::internalize (int elit) {
int ilit;
if (elit) {
assert (elit != INT_MIN);
const int eidx = abs (elit);
if (eidx > max_var)
init (eidx);
ilit = e2i[eidx];
if (elit < 0)
ilit = -ilit;
if (!ilit) {
assert (internal->max_var < INT_MAX);
ilit = internal->max_var + 1u;
internal->init_vars (ilit);
e2i[eidx] = ilit;
LOG ("mapping external %d to internal %d", eidx, ilit);
e2i[eidx] = ilit;
internal->i2e.push_back (eidx);
assert (internal->i2e[ilit] == eidx);
assert (e2i[eidx] == ilit);
if (elit < 0)
ilit = -ilit;
}
if (internal->opts.checkfrozen) {
assert (eidx < (int64_t) moltentab.size ());
if (moltentab[eidx])
FATAL ("can not reuse molten literal %d", eidx);
}
Flags &f = internal->flags (ilit);
if (f.status == Flags::UNUSED)
internal->mark_active (ilit);
else if (f.status != Flags::ACTIVE && f.status != Flags::FIXED)
internal->reactivate (ilit);
if (!marked (tainted, elit) && marked (witness, -elit)) {
assert (!internal->opts.checkfrozen);
LOG ("marking tainted %d", elit);
mark (tainted, elit);
}
} else
ilit = 0;
return ilit;
}
void External::add (int elit) {
assert (elit != INT_MIN);
reset_extended ();
if (internal->opts.check &&
(internal->opts.checkwitness || internal->opts.checkfailed))
original.push_back (elit);
const int ilit = internalize (elit);
assert (!elit == !ilit);
// The external literals of the new clause must be saved for later
// when the proof is printed during add_original_lit (0)
if (elit && internal->proof) {
eclause.push_back (elit);
if (internal->opts.lrat && !internal->opts.lratexternal) {
// actually find unit of -elit (flips elit < 0)
unsigned eidx = (elit > 0) + 2u * (unsigned) abs (elit);
assert ((size_t) eidx < ext_units.size ());
const uint64_t id = ext_units[eidx];
bool added = ext_flags[abs (elit)];
if (id && !added) {
ext_flags[abs (elit)] = true;
internal->lrat_chain.push_back (id);
}
}
}
if (!elit && internal->proof && internal->opts.lrat &&
!internal->opts.lratexternal) {
for (const auto &elit : eclause) {
ext_flags[abs (elit)] = false;
}
}
if (elit)
LOG ("adding external %d as internal %d", elit, ilit);
internal->add_original_lit (ilit);
// Clean-up saved external literals once proof line is printed
if (!elit && internal->proof)
eclause.clear ();
}
void External::assume (int elit) {
assert (elit);
reset_extended ();
assumptions.push_back (elit);
const int ilit = internalize (elit);
assert (ilit);
LOG ("assuming external %d as internal %d", elit, ilit);
internal->assume (ilit);
}
bool External::flip (int elit) {
assert (elit);
assert (elit != INT_MIN);
assert (!propagator);
int eidx = abs (elit);
if (eidx > max_var)
return false;
if (marked (witness, elit))
return false;
int ilit = e2i[eidx];
if (!ilit)
return false;
bool res = internal->flip (ilit);
if (res && extended)
reset_extended ();
return res;
}
bool External::flippable (int elit) {
assert (elit);
assert (elit != INT_MIN);
assert (!propagator);
int eidx = abs (elit);
if (eidx > max_var)
return false;
if (marked (witness, elit))
return false;
int ilit = e2i[eidx];
if (!ilit)
return false;
return internal->flippable (ilit);
}
bool External::failed (int elit) {
assert (elit);
assert (elit != INT_MIN);
int eidx = abs (elit);
if (eidx > max_var)
return 0;
int ilit = e2i[eidx];
if (!ilit)
return 0;
if (elit < 0)
ilit = -ilit;
return internal->failed (ilit);
}
void External::constrain (int elit) {
if (constraint.size () && !constraint.back ()) {
LOG (constraint, "replacing previous constraint");
reset_constraint ();
}
assert (elit != INT_MIN);
reset_extended ();
constraint.push_back (elit);
const int ilit = internalize (elit);
assert (!elit == !ilit);
if (elit)
LOG ("adding external %d as internal %d to constraint", elit, ilit);
internal->constrain (ilit);
}
bool External::failed_constraint () {
return internal->failed_constraint ();
}
void External::phase (int elit) {
assert (elit);
assert (elit != INT_MIN);
int eidx = abs (elit);
if (eidx > max_var) {
UNUSED:
LOG ("forcing phase of unused external %d ignored", elit);
return;
}
int ilit = e2i[eidx];
if (!ilit)
goto UNUSED;
if (elit < 0)
ilit = -ilit;
internal->phase (ilit);
}
void External::unphase (int elit) {
assert (elit);
assert (elit != INT_MIN);
int eidx = abs (elit);
if (eidx > max_var) {
UNUSED:
LOG ("resetting forced phase of unused external %d ignored", elit);
return;
}
int ilit = e2i[eidx];
if (!ilit)
goto UNUSED;
if (elit < 0)
ilit = -ilit;
internal->unphase (ilit);
}
/*------------------------------------------------------------------------*/
// External propagation related functions
void External::add_observed_var (int elit) {
if (!propagator) {
LOG ("No connected propagator that could observe the variable, "
"observed flag is not set.");
return;
}
assert (elit);
assert (elit != INT_MIN);
reset_extended (); // tainting!
int eidx = abs (elit);
if (eidx <= max_var &&
(marked (witness, elit) || marked (witness, -elit))) {
LOG ("Error, only clean variables are allowed to become observed.");
assert (false);
// TODO: here needs to come the taint and restore of the newly
// observed variable. Restore_clauses must be called before continue.
// LOG ("marking tainted %d", elit);
// mark (tainted, elit);
// mark (tainted, -elit);
// restore_clauses ...
}
if (eidx >= (int64_t) is_observed.size ())
is_observed.resize (1 + (size_t) eidx, false);
if (is_observed[eidx])
return;
LOG ("marking %d as externally watched", eidx);
// Will do the necessary internalization
freeze (elit);
is_observed[eidx] = true;
int ilit = internalize (elit);
internal->add_observed_var (ilit);
if (propagator->is_lazy)
return;
// Fixed variables are notified only upon assignment. In case
// this variable was already assigned (e.g. via unit clause),
// it must be notified explicitly now. (-> Can cause a repeated fixed
// assignment notification, in case it was unobserved and observed again.)
const int tmp = fixed (elit);
if (!tmp)
return;
int unit = tmp < 0 ? -elit : elit;
LOG ("notify propagator about fixed assignment upon observe for %d",
unit);
propagator->notify_assignment (unit, true);
}
void External::remove_observed_var (int elit) {
if (!propagator) {
LOG ("No connected propagator that could have watched the variable");
return;
}
int eidx = abs (elit);
if (eidx > max_var)
return;
if (is_observed[eidx]) {
// Follow opposite order of add_observed_var, first remove internal
// is_observed
int ilit = e2i[eidx]; // internalize (elit);
internal->remove_observed_var (ilit);
is_observed[eidx] = false;
melt (elit);
LOG ("unmarking %d as externally watched", eidx);
}
}
void External::reset_observed_vars () {
// Shouldn't be called if there is no connected propagator
assert (propagator);
reset_extended ();
assert ((size_t) max_var + 1 == is_observed.size ());
for (auto elit : vars) {
int eidx = abs (elit);
assert (eidx <= max_var);
if (is_observed[eidx]) {
int ilit = internalize (elit);
internal->remove_observed_var (ilit);
LOG ("unmarking %d as externally watched", eidx);
is_observed[eidx] = false;
melt (elit);
}
}
internal->notified = 0;
LOG ("reset notified counter to 0");
}
bool External::observed (int elit) {
assert (elit);
assert (elit != INT_MIN);
int eidx = abs (elit);
if (eidx > max_var)
return false;
if (eidx >= (int) is_observed.size ())
return false;
return is_observed[eidx];
}
bool External::is_witness (int elit) {
assert (elit);
assert (elit != INT_MIN);
int eidx = abs (elit);
if (eidx > max_var)
return false;
return (marked (witness, elit) || marked (witness, -elit));
}
bool External::is_decision (int elit) {
assert (elit);
assert (elit != INT_MIN);
int eidx = abs (elit);
if (eidx > max_var)
return false;
int ilit = internalize (elit);
return internal->is_decision (ilit);
}
/*------------------------------------------------------------------------*/
// Internal checker if 'solve' claims the formula to be satisfiable.
void External::check_satisfiable () {
LOG ("checking satisfiable");
if (!extended)
extend ();
if (internal->opts.checkwitness)
check_assignment (&External::ival);
if (internal->opts.checkassumptions && !assumptions.empty ())
check_assumptions_satisfied ();
if (internal->opts.checkconstraint && !constraint.empty ())
check_constraint_satisfied ();
}
// Internal checker if 'solve' claims formula to be unsatisfiable.
void External::check_unsatisfiable () {
LOG ("checking unsatisfiable");
if (!internal->opts.checkfailed)
return;
if (!assumptions.empty () || !constraint.empty ())
check_failing ();
}
// Check result of 'solve' to be correct.
void External::check_solve_result (int res) {
if (!internal->opts.check)
return;
if (res == 10)
check_satisfiable ();
if (res == 20)
check_unsatisfiable ();
}
// Prepare checking that completely molten literals are not used as argument
// of 'add' or 'assume', which is invalid under freezing semantics. This
// case would be caught by our 'restore' implementation so is only needed
// for checking the deprecated 'freeze' semantics.
void External::update_molten_literals () {
if (!internal->opts.checkfrozen)
return;
assert ((size_t) max_var + 1 == moltentab.size ());
#ifdef LOGGING
int registered = 0, molten = 0;
#endif
for (auto lit : vars) {
if (moltentab[lit]) {
LOG ("skipping already molten literal %d", lit);
#ifdef LOGGING
molten++;
#endif
} else if (frozen (lit))
LOG ("skipping currently frozen literal %d", lit);
else {
LOG ("new molten literal %d", lit);
moltentab[lit] = true;
#ifdef LOGGING
registered++;
molten++;
#endif
}
}
LOG ("registered %d new molten literals", registered);
LOG ("reached in total %d molten literals", molten);
}
int External::solve (bool preprocess_only) {
reset_extended ();
update_molten_literals ();
int res = internal->solve (preprocess_only);
check_solve_result (res);
reset_limits ();
return res;
}
void External::terminate () { internal->terminate (); }
int External::lookahead () {
reset_extended ();
update_molten_literals ();
int ilit = internal->lookahead ();
const int elit =
(ilit && ilit != INT_MIN) ? internal->externalize (ilit) : 0;
LOG ("lookahead internal %d external %d", ilit, elit);
return elit;
}
CaDiCaL::CubesWithStatus External::generate_cubes (int depth,
int min_depth = 0) {
reset_extended ();
update_molten_literals ();
reset_limits ();
auto cubes = internal->generate_cubes (depth, min_depth);
auto externalize = [this] (int ilit) {
const int elit = ilit ? internal->externalize (ilit) : 0;
MSG ("lookahead internal %d external %d", ilit, elit);
return elit;
};
auto externalize_map = [this, externalize] (std::vector cube) {
(void) this;
MSG ("Cube : ");
std::for_each (begin (cube), end (cube), externalize);
};
std::for_each (begin (cubes.cubes), end (cubes.cubes), externalize_map);
return cubes;
}
/*------------------------------------------------------------------------*/
void External::freeze (int elit) {
reset_extended ();
int ilit = internalize (elit);
unsigned eidx = vidx (elit);
if (eidx >= frozentab.size ())
frozentab.resize (eidx + 1, 0);
unsigned &ref = frozentab[eidx];
if (ref < UINT_MAX) {
ref++;
LOG ("external variable %d frozen once and now frozen %u times", eidx,
ref);
} else
LOG ("external variable %d frozen but remains frozen forever", eidx);
internal->freeze (ilit);
}
void External::melt (int elit) {
reset_extended ();
int ilit = internalize (elit);
unsigned eidx = vidx (elit);
assert (eidx < frozentab.size ());
unsigned &ref = frozentab[eidx];
assert (ref > 0);
if (ref < UINT_MAX) {
if (!--ref) {
if (observed (elit)) {
ref++;
LOG ("external variable %d is observed, can not be completely "
"molten",
eidx);
} else
LOG ("external variable %d melted once and now completely melted",
eidx);
} else
LOG ("external variable %d melted once but remains frozen %u times",
eidx, ref);
} else
LOG ("external variable %d melted but remains frozen forever", eidx);
internal->melt (ilit);
}
/*------------------------------------------------------------------------*/
void External::check_assignment (int (External::*a) (int) const) {
// First check all assigned and consistent.
//
for (auto idx : vars) {
if (!(this->*a) (idx))
FATAL ("unassigned variable: %d", idx);
if ((this->*a) (idx) != -(this->*a) (-idx))
FATAL ("inconsistently assigned literals %d and %d", idx, -idx);
}
// Then check that all (saved) original clauses are satisfied.
//
bool satisfied = false;
const auto end = original.end ();
auto start = original.begin (), i = start;
#ifndef QUIET
int64_t count = 0;
#endif
for (; i != end; i++) {
int lit = *i;
if (!lit) {
if (!satisfied) {
fatal_message_start ();
fputs ("unsatisfied clause:\n", stderr);
for (auto j = start; j != i; j++)
fprintf (stderr, "%d ", *j);
fputc ('0', stderr);
fatal_message_end ();
}
satisfied = false;
start = i + 1;
#ifndef QUIET
count++;
#endif
} else if (!satisfied && (this->*a) (lit) > 0)
satisfied = true;
}
VERBOSE (1, "satisfying assignment checked on %" PRId64 " clauses",
count);
}
/*------------------------------------------------------------------------*/
void External::check_assumptions_satisfied () {
for (const auto &lit : assumptions) {
// Not 'signed char' !!!!
const int tmp = ival (lit);
if (tmp < 0)
FATAL ("assumption %d falsified", lit);
if (!tmp)
FATAL ("assumption %d unassigned", lit);
}
VERBOSE (1, "checked that %zd assumptions are satisfied",
assumptions.size ());
}
void External::check_constraint_satisfied () {
for (const auto lit : constraint) {
if (ival (lit) > 0) {
VERBOSE (1, "checked that constraint is satisfied");
return;
}
}
FATAL ("constraint not satisfied");
}
void External::check_failing () {
Solver *checker = new Solver ();
checker->prefix ("checker ");
#ifdef LOGGING
if (internal->opts.log)
checker->set ("log", true);
#endif
for (const auto lit : original)
checker->add (lit);
for (const auto lit : assumptions) {
if (!failed (lit))
continue;
LOG ("checking failed literal %d in core", lit);
checker->add (lit);
checker->add (0);
}
if (failed_constraint ()) {
LOG (constraint, "checking failed constraint");
for (const auto lit : constraint)
checker->add (lit);
} else if (constraint.size ())
LOG (constraint, "constraint satisfied and ignored");
int res = checker->solve ();
if (res != 20)
FATAL ("failed assumptions do not form a core");
delete checker;
VERBOSE (1, "checked that %zd failing assumptions form a core",
assumptions.size ());
}
/*------------------------------------------------------------------------*/
// Traversal of unit clauses is implemented here.
// In principle we want to traverse the clauses of the simplified formula
// only, particularly eliminated variables should be completely removed.
// This poses the question what to do with unit clauses. Should they be
// considered part of the simplified formula or of the witness to construct
// solutions for the original formula? Ideally they should be considered
// to be part of the witness only, i.e., as they have been simplified away.
// Therefore we distinguish frozen and non-frozen units during clause
// traversal. Frozen units are treated as unit clauses while non-frozen
// units are treated as if they were already eliminated and put on the
// extension stack as witness clauses.
// Furthermore, eliminating units during 'compact' could be interpreted as
// variable elimination, i.e., just add the resolvents (remove falsified
// literals), then drop the clauses with the unit, and push the unit on the
// extension stack. This is of course only OK if the user did not freeze
// that variable (even implicitly during assumptions).
// Thanks go to Fahiem Bacchus for asking why there is a necessity to
// distinguish these two cases (frozen and non-frozen units). The answer is
// that it is not strictly necessary, and this distinction could be avoided
// by always treating units as remaining unit clauses, thus only using the
// first of the two following functions and dropping the 'if (!frozen (idx))
// continue;' check in it. This has however the down-side that those units
// are still in the simplified formula and only as units. I would not
// consider such a formula as really being 'simplified'. On the other hand
// if the user explicitly freezes a literal, then it should continue to be
// in the simplified formula during traversal. So also only using the
// second function is not ideal.
// There is however a catch where this solution breaks down (in the sense of
// producing less optimal results - that is keeping units in the formula
// which better would be witness clauses). The problem is with compact
// preprocessing which removes eliminated but also fixed internal variables.
// One internal unit (fixed) variable is kept and all the other external
// literals which became unit are mapped to that internal literal (negated
// or positively). Compact is called non-deterministically from the point
// of the user and thus there is no control on when this happens. If
// compact happens those external units are mapped to a single internal
// literal now and then all share the same 'frozen' counter. So if the
// user freezes one of them all in essence get frozen, which in turn then
// makes a difference in terms of traversing such a unit as unit clause or
// as unit witness.
bool External::traverse_all_frozen_units_as_clauses (ClauseIterator &it) {
if (internal->unsat)
return true;
vector clause;
for (auto idx : vars) {
if (!frozen (idx))
continue;
const int tmp = fixed (idx);
if (!tmp)
continue;
int unit = tmp < 0 ? -idx : idx;
clause.push_back (unit);
if (!it.clause (clause))
return false;
clause.clear ();
}
return true;
}
bool External::traverse_all_non_frozen_units_as_witnesses (
WitnessIterator &it) {
if (internal->unsat)
return true;
vector clause_and_witness;
for (auto idx : vars) {
if (frozen (idx))
continue;
const int tmp = fixed (idx);
if (!tmp)
continue;
int unit = tmp < 0 ? -idx : idx;
clause_and_witness.push_back (unit);
if (!it.witness (clause_and_witness, clause_and_witness))
return false;
clause_and_witness.clear ();
}
return true;
}
/*------------------------------------------------------------------------*/
void External::copy_flags (External &other) const {
const vector &this_ftab = internal->ftab;
vector &other_ftab = other.internal->ftab;
const unsigned limit = min (max_var, other.max_var);
for (unsigned eidx = 1; eidx <= limit; eidx++) {
const int this_ilit = e2i[eidx];
if (!this_ilit)
continue;
const int other_ilit = other.e2i[eidx];
if (!other_ilit)
continue;
if (!internal->active (this_ilit))
continue;
if (!other.internal->active (other_ilit))
continue;
assert (this_ilit != INT_MIN);
assert (other_ilit != INT_MIN);
const Flags &this_flags = this_ftab[abs (this_ilit)];
Flags &other_flags = other_ftab[abs (other_ilit)];
this_flags.copy (other_flags);
}
}
/*------------------------------------------------------------------------*/
void External::export_learned_empty_clause () {
assert (learner);
if (learner->learning (0)) {
LOG ("exporting learned empty clause");
learner->learn (0);
} else
LOG ("not exporting learned empty clause");
}
void External::export_learned_unit_clause (int ilit) {
assert (learner);
if (learner->learning (1)) {
LOG ("exporting learned unit clause");
const int elit = internal->externalize (ilit);
assert (elit);
learner->learn (elit);
learner->learn (0);
} else
LOG ("not exporting learned unit clause");
}
void External::export_learned_large_clause (const vector &clause) {
assert (learner);
size_t size = clause.size ();
assert (size <= (unsigned) INT_MAX);
if (learner->learning ((int) size)) {
LOG ("exporting learned clause of size %zu", size);
for (auto ilit : clause) {
const int elit = internal->externalize (ilit);
assert (elit);
learner->learn (elit);
}
learner->learn (0);
} else
LOG ("not exporting learned clause of size %zu", size);
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/external.hpp 0000664 0000000 0000000 00000032607 14501267155 0017023 0 ustar 00root root 0000000 0000000 #ifndef _external_hpp_INCLUDED
#define _external_hpp_INCLUDED
/*------------------------------------------------------------------------*/
#include "range.hpp"
/*------------------------------------------------------------------------*/
namespace CaDiCaL {
using namespace std;
/*------------------------------------------------------------------------*/
// The CaDiCaL code is split into three layers:
//
// Solver: facade object providing the actual API of the solver
// External: communication layer between 'Solver' and 'Internal'
// Internal: the actual solver code
//
// Note, that 'Solver' is defined in 'cadical.hpp' and 'solver.cpp', while
// 'External' and 'Internal' in '{external,internal}.{hpp,cpp}'.
//
// Also note, that any user should access the library only through the
// 'Solver' API. For the library internal 'Parser' code we make an
// exception and allow access to both 'External' and 'Internal'. The former
// to enforce the same external to internal mapping of variables and the
// latter for profiling and messages. The same applies to 'App'.
//
// The 'External' class provided here stores the information needed to map
// external variable indices to internal variables (actually literals).
// This is helpful for shrinking the working size of the internal solver
// after many variables become inactive. It will also help to provide
// support for extended resolution in the future, since it allows to
// introduce only internally visible variables (even though we do not know
// how to support generating incremental proofs in this situation yet).
//
// External literals are usually called 'elit' and internal 'ilit'.
/*------------------------------------------------------------------------*/
struct Clause;
struct Internal;
struct CubesWithStatus;
/*------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
struct External {
/*==== start of state ==================================================*/
Internal *internal; // The actual internal solver.
int max_var; // External maximum variable index.
size_t vsize; // Allocated external size.
vector vals; // Current external (extended) assignment.
vector e2i; // External 'idx' to internal 'lit'.
vector assumptions; // External assumptions.
vector constraint; // External constraint. Terminated by zero.
vector
ext_units; // External units. Needed to compute lrat for eclause
vector ext_flags; // to avoid duplicate units
vector eclause; // External version of original input clause.
// The extension stack for reconstructing complete satisfying assignments
// (models) of the original external formula is kept in this external
// solver object. It keeps track of blocked clauses and clauses containing
// eliminated variable. These irredundant clauses are stored in terms of
// external literals on the 'extension' stack after mapping the
// internal literals given as arguments with 'externalize'.
bool extended; // Have been extended.
vector extension; // Solution reconstruction extension stack.
vector witness; // Literal witness on extension stack.
vector tainted; // Literal tainted in adding literals.
vector frozentab; // Reference counts for frozen variables.
// Regularly checked terminator if non-zero. The terminator is set from
// 'Solver::set (Terminator *)' and checked by 'Internal::terminating ()'.
Terminator *terminator;
// If there is a learner export learned clauses.
Learner *learner;
void export_learned_empty_clause ();
void export_learned_unit_clause (int ilit);
void export_learned_large_clause (const vector &);
// If there is an external propagator.
ExternalPropagator *propagator;
vector is_observed; // Quick flag for each external variable
void add_observed_var (int elit);
void remove_observed_var (int elit);
void reset_observed_vars ();
bool observed (int elit);
bool is_witness (int elit);
bool is_decision (int elit);
//----------------------------------------------------------------------//
signed char *solution; // Given solution checking for debugging.
vector original; // Saved original formula for checking.
// If 'opts.checkfrozen' is set make sure that only literals are added
// which were never completely molten before. These molten literals are
// marked at the beginning of the 'solve' call. Note that variables
// larger than 'max_var' are not molten and can thus always be used in the
// future. Only needed to check and debug old style freeze semantics.
//
vector moltentab;
//----------------------------------------------------------------------//
const Range vars; // Provides safe variable iterations.
/*==== end of state ====================================================*/
// These two just factor out common sanity (assertion) checking code.
inline int vidx (int elit) const {
assert (elit);
assert (elit != INT_MIN);
int res = abs (elit);
assert (res <= max_var);
return res;
}
inline int vlit (int elit) const {
assert (elit);
assert (elit != INT_MIN);
assert (abs (elit) <= max_var);
return elit;
}
/*----------------------------------------------------------------------*/
// The following five functions push individual literals or clauses on the
// extension stack. They all take internal literals as argument, and map
// them back to external literals first, before pushing them on the stack.
void push_zero_on_extension_stack ();
// Our general version of extension stacks always pushes a set of witness
// literals (for variable elimination the literal of the eliminated
// literal and for blocked clauses the blocking literal) followed by all
// the clause literals starting with and separated by zero.
//
void push_clause_literal_on_extension_stack (int ilit);
void push_witness_literal_on_extension_stack (int ilit);
void push_clause_on_extension_stack (Clause *);
void push_clause_on_extension_stack (Clause *, int witness);
void push_binary_clause_on_extension_stack (int witness, int other);
// The main 'extend' function which extends an internal assignment to an
// external assignment using the extension stack (and sets 'extended').
//
void extend ();
/*----------------------------------------------------------------------*/
// Marking external literals.
unsigned elit2ulit (int elit) const {
assert (elit);
assert (elit != INT_MIN);
const int idx = abs (elit) - 1;
assert (idx <= max_var);
return 2u * idx + (elit < 0);
}
bool marked (const vector &map, int elit) const {
const unsigned ulit = elit2ulit (elit);
return ulit < map.size () ? map[ulit] : false;
}
void mark (vector &map, int elit) {
const unsigned ulit = elit2ulit (elit);
if (ulit >= map.size ())
map.resize (ulit + 1, false);
map[ulit] = true;
}
void unmark (vector &map, int elit) {
const unsigned ulit = elit2ulit (elit);
if (ulit < map.size ())
map[ulit] = false;
}
/*----------------------------------------------------------------------*/
void push_external_clause_and_witness_on_extension_stack (
const vector &clause, const vector &witness);
// Restore a clause, which was pushed on the extension stack.
void restore_clause (const vector::const_iterator &begin,
const vector::const_iterator &end);
void restore_clauses ();
/*----------------------------------------------------------------------*/
// Explicitly freeze and melt literals (instead of just freezing
// internally and implicitly assumed literals). Passes on freezing and
// melting to the internal solver, which has separate frozen counters.
void freeze (int elit);
void melt (int elit);
bool frozen (int elit) {
assert (elit);
assert (elit != INT_MIN);
int eidx = abs (elit);
if (eidx > max_var)
return false;
if (eidx >= (int) frozentab.size ())
return false;
return frozentab[eidx] > 0;
}
/*----------------------------------------------------------------------*/
External (Internal *);
~External ();
void enlarge (int new_max_var); // Enlarge allocated 'vsize'.
void init (int new_max_var); // Initialize up-to 'new_max_var'.
int internalize (int); // Translate external to internal literal.
/*----------------------------------------------------------------------*/
// According to the CaDiCaL API contract (as well as IPASIR) we have to
// forget about the previous assumptions after a 'solve' call. This
// should however be delayed until we transition out of an 'UNSATISFIED'
// state, i.e., after no more 'failed' calls are expected. Note that
// 'failed' requires to know the failing assumptions, and the 'failed'
// status of those should cleared before at start of the next 'solve'.
// As a consequence 'reset_assumptions' is only called from
// 'transition_to_unknown_state' in API calls in 'solver.cpp'.
void reset_assumptions ();
// Similarly a valid external assignment obtained through 'extend' has to
// be reset at each point it risks to become invalid. This is done
// in the external layer in 'external.cpp' functions..
void reset_extended ();
// Finally, the semantics of incremental solving also require that limits
// are only valid for the next 'solve' call. Since the limits can not
// really be queried, handling them is less complex and they are just
// reset immediately at the end of 'External::solve'.
void reset_limits ();
/*----------------------------------------------------------------------*/
// Proxies to IPASIR functions.
void add (int elit);
void assume (int elit);
int solve (bool preprocess_only);
// We call it 'ival' as abbreviation for 'val' with 'int' return type to
// avoid bugs due to using 'signed char tmp = val (lit)', which might turn
// a negative value into a positive one (happened in 'extend').
//
inline int ival (int elit) const {
assert (elit != INT_MIN);
int eidx = abs (elit), res;
if (eidx > max_var)
res = -eidx;
else if ((size_t) eidx >= vals.size ())
res = -eidx;
else
res = vals[eidx] ? eidx : -eidx;
if (elit < 0)
res = -res;
return res;
}
bool flip (int elit);
bool flippable (int elit);
bool failed (int elit);
void terminate ();
// Other important non IPASIR functions.
/*----------------------------------------------------------------------*/
// Add literal to external constraint.
//
void constrain (int elit);
// Returns true if 'solve' returned 20 because of the constraint.
//
bool failed_constraint ();
// Deletes the current constraint clause. Called on
// 'transition_to_unknown_state' and if a new constraint is added. Can be
// called directly using the API.
//
void reset_constraint ();
/*----------------------------------------------------------------------*/
int lookahead ();
CaDiCaL::CubesWithStatus generate_cubes (int, int);
int fixed (int elit) const; // Implemented in 'internal.hpp'.
/*----------------------------------------------------------------------*/
void phase (int elit);
void unphase (int elit);
/*----------------------------------------------------------------------*/
// Traversal functions for the witness stack and units. The explanation
// in 'external.cpp' for why we have to distinguish these cases.
bool traverse_all_frozen_units_as_clauses (ClauseIterator &);
bool traverse_all_non_frozen_units_as_witnesses (WitnessIterator &);
bool traverse_witnesses_backward (WitnessIterator &);
bool traverse_witnesses_forward (WitnessIterator &);
/*----------------------------------------------------------------------*/
// Copy flags for determining preprocessing state.
void copy_flags (External &other) const;
/*----------------------------------------------------------------------*/
// Check solver behaves as expected during testing and debugging.
void check_assumptions_satisfied ();
void check_constraint_satisfied ();
void check_failing ();
void check_solution_on_learned_clause ();
void check_solution_on_shrunken_clause (Clause *);
void check_solution_on_learned_unit_clause (int unit);
void check_no_solution_after_learning_empty_clause ();
void check_learned_empty_clause () {
if (solution)
check_no_solution_after_learning_empty_clause ();
}
void check_learned_unit_clause (int unit) {
if (solution)
check_solution_on_learned_unit_clause (unit);
}
void check_learned_clause () {
if (solution)
check_solution_on_learned_clause ();
}
void check_shrunken_clause (Clause *c) {
if (solution)
check_solution_on_shrunken_clause (c);
}
void check_assignment (int (External::*assignment) (int) const);
void check_satisfiable ();
void check_unsatisfiable ();
void check_solve_result (int res);
void update_molten_literals ();
/*----------------------------------------------------------------------*/
// For debugging and testing only. See 'solution.hpp' for more details.
//
inline int sol (int elit) const {
assert (solution);
assert (elit != INT_MIN);
int eidx = abs (elit);
if (eidx > max_var)
return 0;
int res = solution[eidx];
if (elit < 0)
res = -res;
return res;
}
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/external_propagate.cpp 0000664 0000000 0000000 00000104622 14501267155 0021055 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
#include
namespace CaDiCaL {
/*----------------------------------------------------------------------------*/
//
// Mark a variable as an observed one. It can be a new variable. It is
// assumed to be clean (not eliminated by previous simplifications).
//
void Internal::add_observed_var (int ilit) {
int idx = vidx (ilit);
if (idx >= (int64_t) relevanttab.size ())
relevanttab.resize (1 + (size_t) idx, 0);
unsigned &ref = relevanttab[idx];
if (ref < UINT_MAX) {
ref++;
LOG ("variable %d is observed %u times", idx, ref);
} else
LOG ("variable %d remains observed forever", idx);
}
/*----------------------------------------------------------------------------*/
//
// Removing an observed variable should happen only once it is ensured
// that there is no unexplained propagation in the implication
// graph involving this variable.
//
void Internal::remove_observed_var (int ilit) {
if (!fixed (ilit) && level)
backtrack ();
assert (fixed (ilit) || !level);
const int idx = vidx (ilit);
unsigned &ref = relevanttab[idx];
assert (fixed (ilit) || ref > 0);
if (fixed (ilit))
ref = 0;
else if (ref < UINT_MAX) {
if (!--ref) {
LOG ("variable %d is not observed anymore", idx);
} else
LOG ("variable %d is unobserved once but remains observed %u times",
ilit, ref);
} else
LOG ("variable %d remains observed forever", idx);
}
/*----------------------------------------------------------------------------*/
//
// Supposed to be used only by mobical.
//
bool Internal::observed (int ilit) const {
return relevanttab[vidx (ilit)] > 0;
}
/*----------------------------------------------------------------------------*/
//
// Check if the variable is assigned by decision.
//
bool Internal::is_decision (int ilit) {
if (!level || fixed (ilit) || !val (ilit))
return false;
const int idx = vidx (ilit);
Var &v = var (idx);
#ifndef NDEBUG
LOG (v.reason,
"is_decision: i%d (current level: %d, is_fixed: %d, v.level: %d, "
"is_external_reason: %d, v.reason: )",
ilit, level, fixed (ilit), v.level, v.reason == external_reason);
#endif
if (!v.level || v.reason)
return false;
assert (!v.reason);
return true;
}
/*----------------------------------------------------------------------------*/
//
// Call external propagator to check if there is a literal to be propagated.
// The reason of the propagation is not necessarily asked at that point.
//
// In case the externally propagated literal is already falsified, the
// reason is asked and conflict analysis starts. In case the externally
// propagated literal is already satisfied, nothing happens.
//
bool Internal::external_propagate () {
if (level)
require_mode (SEARCH);
assert (!unsat);
size_t before = trail.size ();
if (!conflict && external_prop && !external_prop_is_lazy) {
#ifndef NDEBUG
LOG ("external propagation starts (decision level: %d, trail size: "
"%zd, notified %zd)",
level, trail.size (), notified);
#endif
// external->reset_extended (); //TODO for inprocessing
notify_assignments ();
int elit = external->propagator->cb_propagate ();
stats.ext_prop.ext_cb++;
stats.ext_prop.eprop_call++;
while (elit) {
assert (external->is_observed[abs (elit)]);
const int ilit = external->internalize (elit); // TODO: try e2i
int tmp = val (ilit);
#ifndef NDEBUG
assert (fixed (ilit) || observed (ilit));
LOG ("External propagation of e%d (i%d val: %d)", elit, ilit, tmp);
#endif
if (!tmp) {
// variable is not assigned, it can be propagated
search_assign_external (ilit);
stats.ext_prop.eprop_prop++;
if (unsat || conflict)
break;
propagate ();
if (unsat || conflict)
break;
notify_assignments ();
} else if (tmp < 0) {
LOG ("External propgation of %d is falsified under current trail",
ilit);
stats.ext_prop.eprop_conf++;
Clause *res = learn_external_reason_clause (ilit, elit);
#ifndef LOGGING
LOG (res, "reason clause of external propagation of %d:", elit);
#endif
int level_before = level;
bool trail_changed =
(handle_external_clause (res) || level != level_before);
if (unsat || conflict)
break;
if (trail_changed) {
propagate ();
if (!unsat && !conflict)
break;
notify_assignments ();
}
} // else (tmp > 0) -> the case of a satisfied literal is ignored
elit = external->propagator->cb_propagate ();
stats.ext_prop.ext_cb++;
stats.ext_prop.eprop_call++;
}
#ifndef NDEBUG
LOG ("External propagation ends (decision level: %d, trail size: %zd, "
"notified %zd)",
level, trail.size (), notified);
#endif
if (!unsat && !conflict) {
bool has_external_clause =
external->propagator->cb_has_external_clause ();
stats.ext_prop.ext_cb++;
stats.ext_prop.elearn_call++;
#ifndef NDEBUG
if (has_external_clause)
LOG ("New external clauses are to be added.");
else
LOG ("No external clauses to be added.");
#endif
while (has_external_clause) {
int level_before = level;
Clause *res = add_external_clause (false, 0);
bool trail_changed =
(handle_external_clause (res) || level != level_before);
if (unsat || conflict)
break;
if (trail_changed) {
propagate ();
if (unsat || conflict)
break;
notify_assignments ();
}
has_external_clause =
external->propagator->cb_has_external_clause ();
stats.ext_prop.ext_cb++;
stats.ext_prop.elearn_call++;
}
}
#ifndef NDEBUG
LOG ("External clause addition ends on decision level %d at trail size "
"%zd (notified %zd)",
level, trail.size (), notified);
#endif
}
if (before < trail.size ())
did_external_prop = true;
return !conflict;
}
/*----------------------------------------------------------------------------*/
//
// Literals of the externally learned clause must be reordered based on the
// assignment levels of the literals.
//
void Internal::move_literal_to_watch (bool other_watch) {
if (clause.size () < 2)
return;
int i = 0;
if (other_watch)
i++;
int highest_position = i;
int highest_literal = clause[i];
int highest_level = var (highest_literal).level;
int highest_value = val (highest_literal);
for (size_t j = i + 1; j < clause.size (); j++) {
const int other = clause[j];
const int other_level = var (other).level;
const int other_value = val (other);
if (other_value < 0) {
if (highest_value >= 0)
continue;
if (other_level <= highest_level)
continue;
} else if (other_value > 0) {
if (highest_value > 0 && other_level >= highest_level)
continue;
} else {
if (highest_value >= 0)
continue;
}
highest_position = j;
highest_literal = other;
highest_level = other_level;
highest_value = other_value;
}
#ifndef NDEBUG
LOG ("highest position: %d highest level: %d highest value: %d",
highest_position, highest_level, highest_value);
#endif
if (highest_position == i)
return;
if (highest_position > i) {
std::swap (clause[i], clause[highest_position]);
}
}
/*----------------------------------------------------------------------------*/
//
// Reads out from the external propagator the lemma/proapgation reason
// clause literal by literal. In case propagated_elit is 0, it is about an
// external clause via 'cb_add_external_clause_lit'. Otherwise, it is about
// learning the reason of 'propagated_elit' via 'cb_add_reason_clause_lit'.
// The learned clause is simplified by the current root-level assignment
// (i.e. root-level falsified literals are removed, root satisfied clauses
// are skipped). Duplicate literals are removed, tauotologies are detected
// and skipped. It always adds the original (un-simplified) external clause
// to the proof as an input (redundant, if as_redundant is true) clause and
// the simplified version of it (except exceptions below) as a derived
// clause.
//
// In case the external clause, after simplifications, is satisfied, no
// clause is constructed, and the function returns 0. In case the external
// clause, after simplifications, is empty, no clause is constructed, unsat
// is set true and the function returns 0. In case the external clause,
// after simplifications, is unit, no clause is constructed,
// 'Internal::clause' has the unit literal (without 0) and the function
// returns 0.
//
// In every other cases a new clause is constructed and the pointer to it is
// returned.
//
Clause *Internal::add_external_clause (bool as_redundant,
int propagated_elit) {
size_t lemma_size = 0;
size_t original_size = 0;
bool skip = false;
unordered_set learned_levels;
size_t unassigned = 0;
int elit = 0;
if (propagated_elit) {
#ifndef NDEBUG
LOG ("add external reason of propagated lit: %d", propagated_elit);
#endif
elit = external->propagator->cb_add_reason_clause_lit (propagated_elit);
} else
elit = external->propagator->cb_add_external_clause_lit ();
// Read out the external lemma into original and simplify it into clause
assert (clause.empty ());
assert (original.empty ());
assert (lrat_chain.empty ());
vector external_original;
vector marking;
while (elit) {
assert (external->is_observed[abs (elit)]);
original_size++;
if (opts.check && (opts.checkwitness || opts.checkfailed)) {
external->original.push_back (elit);
}
if (proof || (opts.lrat && !opts.lratexternal))
external_original.push_back (elit);
bool added_id = false;
if (opts.lrat && !opts.lratexternal) {
// actually find unit of -elit (flips elit < 0)
unsigned eidx = (elit > 0) + 2u * (unsigned) abs (elit);
assert ((size_t) eidx < external->ext_units.size ());
const uint64_t id = external->ext_units[eidx];
added_id = id > 0;
bool added = external->ext_flags[abs (elit)];
if (id && !added) {
external->ext_flags[abs (elit)] = true;
lrat_chain.push_back (id);
}
}
// TODO: double-check the consequences of internalization (tainting!)
const int ilit = external->internalize (elit);
original.push_back (ilit);
#ifndef NDEBUG
assert (fixed (ilit) || observed (ilit));
LOG ("elit: %d -> ilit: %d", elit, ilit);
#endif
int tmp = marked (ilit);
if (tmp > 0) {
LOG ("removing duplicated literal %d", ilit);
} else if (tmp < 0) {
LOG ("tautological since both %d and %d occur", -ilit, ilit);
if (propagated_elit)
LOG ("tautological clause was given as reason of external "
"propagation.");
skip = true;
} else {
// Mark lit to recognize tautology and duplication
mark (ilit);
marking.push_back (ilit);
tmp = fixed (ilit);
if (tmp > 0) {
LOG ("root level satisfied literal %d", ilit);
if (propagated_elit)
LOG ("satisfied clause was given as reason of external "
"propagation.");
skip = true;
if (propagated_elit)
elit = external->propagator->cb_add_reason_clause_lit (
propagated_elit);
else
elit = external->propagator->cb_add_external_clause_lit ();
continue;
} else if (tmp < 0) {
LOG ("root level falsified literal %d is ignored", ilit);
if (opts.lrat && !opts.lratexternal && !added_id) {
uint64_t uid = (unit_clauses[vlit (-ilit)]);
assert (uid);
lrat_chain.push_back (uid);
}
if (propagated_elit)
elit = external->propagator->cb_add_reason_clause_lit (
propagated_elit);
else
elit = external->propagator->cb_add_external_clause_lit ();
continue;
}
tmp = val (ilit);
if (tmp)
learned_levels.insert (var (ilit).level);
else
unassigned++;
#ifndef NDEBUG
if (tmp) {
LOG ("elit: %d -> ilit: %d val: %d level: %d", elit, ilit, tmp,
var (ilit).level);
} else {
LOG ("elit: %d -> ilit: %d val: %d level: %d - unassigned", elit,
ilit, tmp, var (ilit).level);
}
#endif
clause.push_back (ilit);
lemma_size++;
}
if (propagated_elit)
elit =
external->propagator->cb_add_reason_clause_lit (propagated_elit);
else
elit = external->propagator->cb_add_external_clause_lit ();
}
if (opts.check && (opts.checkwitness || opts.checkfailed)) {
external->original.push_back (elit);
}
uint64_t id = ++clause_id;
if (proof)
proof->add_external_original_clause (id, external_original);
if (opts.lrat && !opts.lratexternal) {
for (const auto &lit : external_original) {
external->ext_flags[abs (lit)] = false;
}
}
// Clean up marks
for (const auto &lit : marking)
unmark (lit);
if (skip) {
assert (!propagated_elit);
// TODO: handle the error-case if a satisfied clause is given as reason
// of propagation.
if (proof)
proof->delete_external_original_clause (id, external_original);
original.clear ();
clause.clear ();
lrat_chain.clear ();
external_original.clear ();
return 0;
}
if (original_size > lemma_size) {
external->check_learned_clause ();
if (proof) {
uint64_t new_id = ++clause_id;
if (opts.lrat && !opts.lratexternal) {
lrat_chain.push_back (id);
proof->add_derived_clause (new_id, clause, lrat_chain);
} else {
proof->add_derived_clause (new_id, clause);
}
proof->delete_external_original_clause (id, external_original);
id = new_id;
}
}
lrat_chain.clear ();
original.clear ();
external_original.clear ();
int glue = (int) (learned_levels.size () + unassigned);
assert (glue <= (int) clause.size ());
if (lemma_size > 1) {
move_literal_to_watch (false);
move_literal_to_watch (true);
#ifndef NDEBUG
check_watched_literal_invariants ();
#endif
Clause *res = new_clause (as_redundant, glue);
res->id = id;
assert (watching ());
watch_clause (res);
clause.clear ();
LOG (res, "New external clause is constructed: ");
return res;
} else {
// TODO: give ids to these...
assert (clause.size () < 2);
if (clause.empty ()) {
if (!original_size)
VERBOSE (1, "empty clause is learnt from external propagator");
else
MSG ("falsified clause is learnt from external propagator");
unsat = true;
conflict_id = id;
} else {
assert (clause.size () == 1);
LOG (clause, "unit clause is learnt from external propagator");
const int lit = clause[0];
assert (lit);
assert (!unit_clauses[vlit (lit)]);
assert (!unsat);
unit_clauses[vlit (lit)] = id;
}
return 0;
}
return 0;
}
/*----------------------------------------------------------------------------*/
//
// Recursively calls 'learn_external_reason_clause' to explain every
// backward reachable externally propagated literal starting from 'ilit'.
//
void Internal::explain_reason (int ilit, Clause *reason, int &open) {
#ifndef NDEBUG
LOG (reason, "explain_reason %d (open: %d)", ilit, open);
#endif
assert (reason);
assert (reason != external_reason);
for (const auto &other : *reason) {
if (other == ilit)
continue;
Flags &f = flags (other);
if (f.seen)
continue;
Var &v = var (other);
if (!v.level)
continue;
assert (val (other) < 0);
assert (v.level <= level);
if (v.reason == external_reason) {
v.reason = learn_external_reason_clause (-other);
if (!v.reason) {
v.level = 0;
learn_external_propagated_unit_clause (-other);
}
}
if (v.level && v.reason) {
f.seen = true;
open++;
}
}
}
/*----------------------------------------------------------------------------*/
//
// In case external propagation was used, the reason clauses of the relevant
// propagations must be learned lazily before/during conflict analysis.
// While conflict analysis needs to analyze only the current level, lazy
// clause learning must check every clause on every level that is backward
// reachable from the conflicting clause to guarantee that the assignment
// levels of the variables are accurate. So this explanation round is
// separated from the conflict analysis, thereby guranteeing that the flags
// and datastructures can be properly used later.
//
// This function must be called before the conflict analysis, in order to
// guarantee that every relevant reason clause is indeed learned already and
// to be sure that the levels of assignments are set correctly.
//
// Later TODO: experiment with bounded explanation (explain only those
// literals that are directly used during conflict analysis +
// minimizing/shrinking). The assignment levels are then only
// over-approximated.
//
void Internal::explain_external_propagations () {
assert (conflict);
Clause *reason = conflict;
int i = trail.size (); // Start at end-of-trail
int open = 0; // Seen but not explained literal
explain_reason (0, reason, open); // marks conflict clause lits as seen
std::vector seen_lits;
while (i > 0) {
const int lit = trail[--i];
if (!flags (lit).seen)
continue;
seen_lits.push_back (lit);
Var &v = var (lit);
if (!v.level)
continue;
if (v.reason) {
open--;
explain_reason (lit, v.reason, open);
}
if (!open)
break;
}
assert (!open);
// Traverse now in the opposite direction (from lower to higher levels)
// and calculate the actual assignment level for the seen assignments.
for (auto it = seen_lits.rbegin (); it != seen_lits.rend (); ++it) {
const int lit = *it;
Flags &f = flags (lit);
Var &v = var (lit);
if (v.reason) {
int real_level = 0;
for (const auto &other : *v.reason) {
if (other == lit)
continue;
int tmp = var (other).level;
if (tmp > real_level)
real_level = tmp;
}
if (v.level && !real_level) {
build_chain_for_units (lit, v.reason, 1);
learn_unit_clause (lit);
lrat_chain.clear ();
}
v.level = real_level;
}
f.seen = false;
}
#ifndef NDEBUG
for (const auto &lit : trail) {
assert (!flags (lit).seen);
}
#endif
}
/*----------------------------------------------------------------------------*/
//
// Learns the reason clause of the propagation of ilit from the
// external propagator via 'add_external_clause'.
// In case of falsified propagation steps, if the propagated literal is
// already fixed to the opposite value externalize will not necessarily give
// back the original elit (but an equivalent one). To avoid that, in
// falsified propagation cases the propagated elit is added as a second
// argument.
//
Clause *Internal::learn_external_reason_clause (int ilit,
int falsified_elit) {
assert (external->propagator);
assert (clause.empty ());
assert (original.empty ());
stats.ext_prop.eprop_expl++;
int elit = 0;
if (!falsified_elit) {
elit = externalize (ilit);
assert (!fixed (ilit));
} else
elit = falsified_elit;
LOG ("ilit: %d, elit: %d", ilit, elit);
Clause *res = add_external_clause (false, elit);
if (res) {
// All went well, new external clause was learned and can be returned
LOG (res, "reason of %d is learned from external propagator: ", elit);
assert (clause.empty ());
return res;
}
assert (!res);
LOG ("reason of %d is asked from external propagator: unit", elit);
// No clause can be constructed because the reason is either a unit
// clause or was empty (later should never happen with a correct external
// propagator).
assert (clause.size () < 2);
if (clause.size () == 1) {
if (falsified_elit) {
// The forced literal is kept in clause[0] in that corner-case, the
// return side must clean it up.
return 0;
} else {
assert (clause[0] == ilit);
// The reason of external propagation is a unit clause (after
// root-level simplifications).
// By returning 0 as reason, the literal will be learned as a new
// root-level unit clause.
clause.clear ();
return 0;
}
} else {
assert (clause.empty ());
LOG ("empty reason clause was added (rendering the problem to unsat).");
// Same as before, return 0, but set unsat to true, so the problem can
// be recognized.
assert (unsat);
return 0;
}
}
/*----------------------------------------------------------------------------*/
//
// This function decides what to do upon learning a new clause from the
// external propagator. The possible scenarios are:
// 1. External clause is satisfied by root-level assignment.
// In that case nothing happens, the function returns false.
// 2. External clause is a unit clause (after root-level simplifications).
// In that case the solver backtracks to root-level, assigns the unit and
// does BCP.
// If that new unit+BCP leads to a conflict, unsat is set true and the
// function returns true. Otherwise, the function returns true, without
// changing 'unsat'.
// 3. External clause is empty (after root-level simplifications).
// In that case variable 'unsat' is set true and the function returns
// true.
// 4. External clause is falsified under the current trail (after root-level
// simplifications, but not empty under the root-level assignments).
// In that case, if chrono is off, the solver backtracks to the highest
// level of the external clause. Variable 'conflict' is set to point to
// the external clause and the function returns true (if did backtrack)
// or false (ow).
// 5. External clause propagates under the current trail (after root-level
// simplifications, but not unit under the root-level assignments).
// In that case, if chrono is off, the solver backtracks to the highest
// assigned level of the external clause. Then, 'search_assign_driving'
// is called on the unassigned literal, giving the external clause as a
// reason and the function returns true.
// 6. External clause does not fall into any of the previous cases.
// The external clause is learned, but nothing else happens, the function
// returns false.
//
bool Internal::handle_external_clause (Clause *res) {
bool trail_changed = false;
if (!res) {
if (clause.empty () && !unsat) {
// Might be an ignored or root-satisfied clause, there is nothing to
// do with it
LOG (clause, "No external clause is learned.");
stats.ext_prop.elearn_conf++;
// trail did not change
return false;
} else {
stats.ext_prop.elearned++;
assert (clause.size () < 2);
if (clause.size () == 1) {
LOG (clause, "External clause is unit clause, backtrack to fix it "
"and propagate:");
stats.ext_prop.elearn_prop++;
if (level)
backtrack ();
const uint64_t id = clause_id;
assign_original_unit (id, clause[0]);
clause.clear ();
if (unsat) {
LOG ("External clause made the formula unsatisfiable.");
assert (conflict);
stats.ext_prop.elearn_conf++;
} else {
stats.ext_prop.elearn_prop++;
}
return true;
} else if (clause.size () == 0) {
// Empty/Falsified clause is learned from the external propagator
assert (unsat);
stats.ext_prop.elearn_conf++;
return false;
}
}
} else if (val (res->literals[0]) < 0 && val (res->literals[1]) < 0) {
if (!opts.chrono) {
const int conflict_level = var (res->literals[0]).level;
if (conflict_level != level) {
// propagated = var(res->literals[0]).trail;
backtrack (conflict_level);
trail_changed = true;
}
}
conflict = res;
stats.ext_prop.elearned++;
stats.ext_prop.elearn_conf++;
return trail_changed;
} else if (!val (res->literals[0]) && val (res->literals[1]) < 0) {
if (!opts.chrono) {
const int last_assignment_level = var (res->literals[1]).level;
if (last_assignment_level != level) {
backtrack (last_assignment_level);
}
}
search_assign_driving (res->literals[0], res);
stats.ext_prop.elearned++;
stats.ext_prop.elearn_conf++;
return true;
// TODO: repropagation case, the new clause maybe allows to propagate an
// already propagated literal on a lower decision level.
//
// } else if (val(res->literals[0]) > 0 && val(res->literals[1]) < 0) {
// const int last_assignment_level = var(res->literals[1]).level;
// if (last_assignment_level < var(res->literals[0]).level) {
// LOG("Lower (%d instead of %d) re-propagation of %d is possible due to
// external
// lemma.",last_assignment_level,res->literals[0]).level,res->literals[0]);
// backtrack (last_assignment_level);
// search_assign (res->literals[0], res);
// trail_changed = true;
// }
} else {
LOG (res, "Learning external clause (no propagation).");
stats.ext_prop.elearned++;
return false;
}
return false;
}
/*----------------------------------------------------------------------------*/
//
// Asks the external propagator if the current solution is OK
// by calling 'cb_check_found_model (model)'.
//
// The checked model is built up after everything is restored
// from the reconstruction stack and every variable is reactivated
// and so it is not just simply the trail (i.e. it can be expensive).
//
// If the external propagator approves the model, the function
// returns true.
//
// If the propagator does not approve the model, the solver asks
// the propagator to add an external clause.
// This external clause, however, does NOT have to be falsified by
// the current model. The possible cases and reactions are described
// below in the function. The possible states after that function:
// - A solution was found and accepted by the external propagator
// - A conflicting clause was learned from the external propagator
// - The empty clause was learned due to something new learned from
// the external propagator.
//
bool Internal::external_check_solution () {
if (!external_prop)
return true;
bool trail_changed = true;
bool added_new_clauses = false;
while (trail_changed || added_new_clauses) {
notify_assignments ();
if (!satisfied ())
break;
trail_changed = false; // to be on the safe side
added_new_clauses = false;
LOG ("Final check by external propagator is invoked.");
stats.ext_prop.echeck_call++;
external->reset_extended ();
external->extend ();
std::vector etrail;
// Here the variables must be filtered by external->is_observed,
// because fixed variables are internally not necessarily observed
// anymore.
for (unsigned i = 1; i <= (unsigned) external->max_var; i++) {
if (!external->is_observed[i])
continue;
const int tmp = external->ival (i);
if (tmp > 0)
etrail.push_back (i);
else
etrail.push_back (-i);
#ifndef NDEBUG
#ifdef LOGGING
bool p = external->vals[i];
LOG ("evals[%d]: %d ival(%d): %d", i, p, i, tmp);
#endif
#endif
}
bool is_consistent =
external->propagator->cb_check_found_model (etrail);
stats.ext_prop.ext_cb++;
if (is_consistent) {
LOG ("Found solution is approved by external propagator.");
return true;
}
bool has_external_clause =
external->propagator->cb_has_external_clause ();
stats.ext_prop.ext_cb++;
stats.ext_prop.elearn_call++;
assert (has_external_clause);
LOG ("Found solution triggered new clauses from external propagator.");
while (has_external_clause) {
Clause *res = add_external_clause (false, 0);
trail_changed = handle_external_clause (res);
added_new_clauses = true;
//
// There are many possible scenarios here:
// - Learned conflicting clause: return to CDCL loop (conflict true)
// - Learned conflicting unit clause that after backtrack+BCP leads to
// a new complete solution: force the outer loop to check the new
// model (trail_changed is true, but (conflict & unsat) is false)
// - Learned empty clause: return to CDCL loop (unsat true)
// - Learned a non-conflicting unit clause:
// Though it does not invalidate the current solution, the solver
// will backtrack to the root level and will repropagate it. The
// search will start again (saved phases hopefully make it quick),
// but it is needed in order to guarantee that every fixed variable
// is properly handled+notified (important for incremental use
// cases).
// - Otherwise: the solution is considered approved and the CDCL-loop
// can return with res = 10.
//
if (unsat || conflict || trail_changed)
break;
has_external_clause = external->propagator->cb_has_external_clause ();
stats.ext_prop.ext_cb++;
stats.ext_prop.elearn_call++;
}
LOG ("No more external clause to add.");
if (unsat || conflict)
break;
}
if (!unsat && conflict) {
const int conflict_level = var (conflict->literals[0]).level;
if (conflict_level != level) {
backtrack (conflict_level);
}
}
return !conflict;
}
/*----------------------------------------------------------------------------*/
//
// Notify the external propagator that an observed variable got assigned.
//
void Internal::notify_assignments () {
if (!external_prop || external_prop_is_lazy)
return;
const size_t end_of_trail = trail.size ();
if (notified < end_of_trail)
LOG ("notify external propagator about new assignments");
while (notified < end_of_trail) {
int ilit = trail[notified++];
if (fixed (ilit) || !observed (ilit))
continue; // fixed literals are notified eagerly in mark_fixed, not
// here
int elit = externalize (ilit); // TODO: double-check tainting
assert (elit);
assert (external->observed (elit));
external->propagator->notify_assignment (elit, false);
}
}
/*----------------------------------------------------------------------------*/
//
// Notify the external propagator that a new decision level is started.
//
void Internal::notify_decision () {
if (!external_prop || external_prop_is_lazy)
return;
external->propagator->notify_new_decision_level ();
}
/*----------------------------------------------------------------------------*/
//
// Notify the external propagator that backtrack to new_level.
//
void Internal::notify_backtrack (size_t new_level) {
if (!external_prop || external_prop_is_lazy)
return;
external->propagator->notify_backtrack (new_level);
}
/*----------------------------------------------------------------------------*/
//
// Ask the external propagator if there is a suggested literal as next
// decision.
//
int Internal::ask_decision () {
if (!external_prop || external_prop_is_lazy)
return 0;
int elit = external->propagator->cb_decide ();
stats.ext_prop.ext_cb++;
if (!elit)
return 0;
LOG ("external propagator wants to proposes a decision: %d", elit);
assert (external->is_observed[abs (elit)]);
if (!external->is_observed[abs (elit)])
return 0;
const int ilit = external->internalize (elit);
assert (fixed (ilit) || observed (ilit));
LOG ("Asking external propagator for decision returned: %d (internal: "
"%d, fixed: %d, val: %d)",
elit, ilit, fixed (ilit), val (ilit));
if (fixed (ilit) || val (ilit)) {
LOG ("Proposed decision variable is already assigned, falling back to "
"internal decision.");
return 0;
}
return ilit;
}
/*----------------------------------------------------------------------------*/
//
// Check that the literals in the clause are properly ordered. Used only
// internally for debug purposes.
//
void Internal::check_watched_literal_invariants () {
#ifndef NDEBUG
int v0 = 0;
int v1 = 0;
if (val (clause[0]) > 0)
v0 = 1;
else if (val (clause[0]) < 0)
v0 = -1;
if (val (clause[1]) > 0)
v1 = 1;
else if (val (clause[1]) < 0)
v1 = -1;
assert (v0 >= v1);
#endif
if (val (clause[0]) > 0) {
if (val (clause[1]) > 0) { // Case 1: Both literals are satisfied
// They are ordered by lower to higher decision level
assert (var (clause[0]).level <= var (clause[1]).level);
// Every other literal of the clause is either
// - satisfied at higher level
// - unassigned
// - falsified
for (size_t i = 2; i < clause.size (); i++)
assert (val (clause[i]) <= 0 ||
(var (clause[1]).level <= var (clause[i]).level));
} else if (val (clause[1]) ==
0) { // Case 2: First satisfied, next unassigned
// Every other literal of the clause is either
// - unassigned
// - falsified
for (size_t i = 2; i < clause.size (); i++)
assert (val (clause[i]) <= 0);
} else { // Case 3: First satisfied, next falsified -> could have been a
// reason of a previous propagation
// Every other literal of the clause is falsified but at a lower
// decision level
for (size_t i = 2; i < clause.size (); i++)
assert (val (clause[i]) < 0 &&
(var (clause[1]).level >= var (clause[i]).level));
}
} else if (val (clause[0]) == 0) {
if (val (clause[1]) == 0) { // Case 4: Both literals are unassigned
// Every other literal of the clause is either
// - unassigned
// - falsified
for (size_t i = 2; i < clause.size (); i++)
assert (val (clause[i]) <= 0);
} else { // Case 5: First unassigned, next falsified -> PROPAGATE
// Every other literal of the clause is falsified but at a lower
// decision level
for (size_t i = 2; i < clause.size (); i++)
assert (val (clause[i]) < 0 &&
(var (clause[1]).level >= var (clause[i]).level));
}
} else {
assert (val (clause[0]) < 0 &&
val (clause[1]) < 0); // Case 6: Both literals are falsified
// They are ordered by higher to lower decision level
assert (var (clause[0]).level >= var (clause[1]).level);
// Every other literal of the clause is falsified, but at a lower level
for (size_t i = 2; i < clause.size (); i++)
assert (val (clause[i]) < 0 &&
(var (clause[1]).level >= var (clause[i]).level));
}
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/file.cpp 0000664 0000000 0000000 00000027446 14501267155 0016120 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
/*------------------------------------------------------------------------*/
// Some more low-level 'C' headers.
extern "C" {
#include
#include
#include
#include
#include
#include
#include
}
#ifndef _WIN32
extern "C" {
#include
};
#endif
/*------------------------------------------------------------------------*/
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// Private constructor.
File::File (Internal *i, bool w, int c, int p, FILE *f, const char *n)
:
#ifndef QUIET
internal (i),
#endif
#if !defined(QUIET) || !defined(NDEBUG)
writing (w),
#endif
close_file (c), child_pid (p), file (f), _name (n), _lineno (1),
_bytes (0) {
(void) i, (void) w;
assert (f), assert (n);
}
/*------------------------------------------------------------------------*/
bool File::exists (const char *path) {
struct stat buf;
if (stat (path, &buf))
return false;
if (access (path, R_OK))
return false;
return true;
}
bool File::writable (const char *path) {
int res;
if (!path)
res = 1;
else if (!strcmp (path, "/dev/null"))
res = 0;
else {
if (!*path)
res = 2;
else {
struct stat buf;
const char *p = strrchr (path, '/');
if (!p) {
if (stat (path, &buf))
res = ((errno == ENOENT) ? 0 : -2);
else if (S_ISDIR (buf.st_mode))
res = 3;
else
res = (access (path, W_OK) ? 4 : 0);
} else if (!p[1])
res = 5;
else {
size_t len = p - path;
char *dirname = new char[len + 1];
strncpy (dirname, path, len);
dirname[len] = 0;
if (stat (dirname, &buf))
res = 6;
else if (!S_ISDIR (buf.st_mode))
res = 7;
else if (access (dirname, W_OK))
res = 8;
else if (stat (path, &buf))
res = (errno == ENOENT) ? 0 : -3;
else
res = access (path, W_OK) ? 9 : 0;
delete[] dirname;
}
}
}
return !res;
}
// These are signatures for supported compressed file types. In 2018 the
// SAT Competition was running on StarExec and used internally 'bzip2'
// compressed files, but gave them uncompressed to the solver using exactly
// the same path (with '.bz2' suffix). Then 'CaDiCaL' tried to read that
// actually uncompressed file through 'bzip2', which of course failed. Now
// we double check and fall back to reading the file as is, if the signature
// does not match after issuing a warning.
static int xzsig[] = {0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00, 0x00, EOF};
static int bz2sig[] = {0x42, 0x5A, 0x68, EOF};
static int gzsig[] = {0x1F, 0x8B, EOF};
static int sig7z[] = {0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C, EOF};
static int lzmasig[] = {0x5D, EOF};
bool File::match (Internal *internal, const char *path, const int *sig) {
assert (path);
FILE *tmp = fopen (path, "r");
if (!tmp) {
WARNING ("failed to open '%s' to check signature", path);
return false;
}
bool res = true;
for (const int *p = sig; res && (*p != EOF); p++)
res = (cadical_getc_unlocked (tmp) == *p);
fclose (tmp);
if (!res)
WARNING ("file type signature check for '%s' failed", path);
return res;
}
size_t File::size (const char *path) {
struct stat buf;
if (stat (path, &buf))
return 0;
return (size_t) buf.st_size;
}
// Check that 'prg' is in the 'PATH' and thus can be found if executed
// through 'popen' or 'exec'.
char *File::find_program (const char *prg) {
size_t prglen = strlen (prg);
const char *c = getenv ("PATH");
if (!c)
return 0;
size_t len = strlen (c);
char *e = new char[len + 1];
strcpy (e, c);
char *res = 0;
for (char *p = e, *q; !res && p < e + len; p = q) {
for (q = p; *q && *q != ':'; q++)
;
*q++ = 0;
size_t pathlen = (q - p) + prglen;
char *path = new char[pathlen + 1];
snprintf (path, pathlen + 1, "%s/%s", p, prg);
assert (strlen (path) == pathlen);
if (exists (path))
res = path;
else
delete[] path;
}
delete[] e;
return res;
}
/*------------------------------------------------------------------------*/
FILE *File::open_file (Internal *internal, const char *path,
const char *mode) {
(void) internal;
return fopen (path, mode);
}
FILE *File::read_file (Internal *internal, const char *path) {
MSG ("opening file to read '%s'", path);
return open_file (internal, path, "r");
}
FILE *File::write_file (Internal *internal, const char *path) {
MSG ("opening file to write '%s'", path);
return open_file (internal, path, "w");
}
/*------------------------------------------------------------------------*/
void File::split_str (const char *command, std::vector &argv) {
const char *c = command;
while (*c && *c == ' ')
c++;
while (*c) {
const char *p = c;
while (*p && *p != ' ')
p++;
const size_t bytes = p - c;
char *arg = new char[bytes + 1];
(void) strncpy (arg, c, bytes);
arg[bytes] = 0;
argv.push_back (arg);
while (*p && *p == ' ')
p++;
c = p;
}
}
void File::delete_str_vector (std::vector &argv) {
for (auto str : argv)
delete[] str;
}
FILE *File::open_pipe (Internal *internal, const char *fmt,
const char *path, const char *mode) {
#ifdef QUIET
(void) internal;
#endif
size_t prglen = 0;
while (fmt[prglen] && fmt[prglen] != ' ')
prglen++;
char *prg = new char[prglen + 1];
strncpy (prg, fmt, prglen);
prg[prglen] = 0;
char *found = find_program (prg);
if (found)
MSG ("found '%s' in path for '%s'", found, prg);
if (!found)
MSG ("did not find '%s' in path", prg);
delete[] prg;
if (!found)
return 0;
delete[] found;
size_t cmd_size = strlen (fmt) + strlen (path);
char *cmd = new char[cmd_size];
snprintf (cmd, cmd_size, fmt, path);
FILE *res = popen (cmd, mode);
delete[] cmd;
return res;
}
FILE *File::read_pipe (Internal *internal, const char *fmt, const int *sig,
const char *path) {
if (!File::exists (path)) {
LOG ("file '%s' does not exist", path);
return 0;
}
LOG ("file '%s' exists", path);
if (sig && !File::match (internal, path, sig))
return 0;
LOG ("file '%s' matches signature for '%s'", path, fmt);
MSG ("opening pipe to read '%s'", path);
return open_pipe (internal, fmt, path, "r");
}
#ifndef _WIN32
FILE *File::write_pipe (Internal *internal, const char *command,
const char *path, int &child_pid) {
assert (command[0] && command[0] != ' ');
MSG ("writing through command '%s' to '%s'", command, path);
std::vector args;
split_str (command, args);
assert (!args.empty ());
args.push_back (0);
char **argv = args.data ();
char *absolute_command_path = find_program (argv[0]);
int pipe_fds[2], out;
FILE *res = 0;
if (!absolute_command_path)
MSG ("could not find '%s' in 'PATH' environment variable", argv[0]);
else if (pipe (pipe_fds) < 0)
MSG ("could not generate pipe to '%s' command", command);
else if ((out = ::open (path, O_CREAT | O_TRUNC | O_WRONLY, 0644)) < 0)
MSG ("could not open '%s' for writing", path);
else if ((child_pid = fork ()) < 0) {
MSG ("could not fork process to execute '%s' command", command);
::close (out);
} else if (child_pid) {
::close (pipe_fds[0]);
res = ::fdopen (pipe_fds[1], "w");
} else {
::close (pipe_fds[1]);
::close (0);
::close (1);
if (command[0] == '7') // Surpress '7z' verbose output on 'stderr'.
::close (2);
int in = dup (pipe_fds[0]);
assert (in == 0), (void) in;
int tmp = dup2 (out, 1);
assert (tmp == 1), (void) tmp;
execv (absolute_command_path, argv);
_exit (1);
}
if (absolute_command_path)
delete[] absolute_command_path;
delete_str_vector (args);
return res;
}
#endif
/*------------------------------------------------------------------------*/
File *File::read (Internal *internal, FILE *f, const char *n) {
return new File (internal, false, 0, 0, f, n);
}
File *File::write (Internal *internal, FILE *f, const char *n) {
return new File (internal, true, 0, 0, f, n);
}
File *File::read (Internal *internal, const char *path) {
FILE *file;
int close_input = 2;
if (has_suffix (path, ".xz")) {
file = read_pipe (internal, "xz -c -d %s", xzsig, path);
if (!file)
goto READ_FILE;
} else if (has_suffix (path, ".lzma")) {
file = read_pipe (internal, "lzma -c -d %s", lzmasig, path);
if (!file)
goto READ_FILE;
} else if (has_suffix (path, ".bz2")) {
file = read_pipe (internal, "bzip2 -c -d %s", bz2sig, path);
if (!file)
goto READ_FILE;
} else if (has_suffix (path, ".gz")) {
file = read_pipe (internal, "gzip -c -d %s", gzsig, path);
if (!file)
goto READ_FILE;
} else if (has_suffix (path, ".7z")) {
file = read_pipe (internal, "7z x -so %s 2>/dev/null", sig7z, path);
if (!file)
goto READ_FILE;
} else {
READ_FILE:
file = read_file (internal, path);
close_input = 1;
}
if (!file)
return 0;
return new File (internal, false, close_input, 0, file, path);
}
File *File::write (Internal *internal, const char *path) {
FILE *file;
int close_output = 3, child_pid = 0;
#ifndef _WIN32
if (has_suffix (path, ".xz"))
file = write_pipe (internal, "xz -c", path, child_pid);
else if (has_suffix (path, ".bz2"))
file = write_pipe (internal, "bzip2 -c", path, child_pid);
else if (has_suffix (path, ".gz"))
file = write_pipe (internal, "gzip -c", path, child_pid);
else if (has_suffix (path, ".7z"))
file = write_pipe (internal, "7z a -an -txz -si -so", path, child_pid);
else
#endif
file = write_file (internal, path), close_output = 1;
if (!file)
return 0;
return new File (internal, true, close_output, child_pid, file, path);
}
void File::close () {
assert (file);
if (close_file == 0) {
MSG ("disconnecting from '%s'", name ());
}
if (close_file == 1) {
MSG ("closing file '%s'", name ());
fclose (file);
}
if (close_file == 2) {
MSG ("closing input pipe to read '%s'", name ());
pclose (file);
}
#ifndef _WIN32
if (close_file == 3) {
MSG ("closing output pipe to write '%s'", name ());
fclose (file);
waitpid (child_pid, 0, 0);
}
#endif
file = 0; // mark as closed
// TODO what about error checking for 'fclose', 'pclose' or 'waitpid'?
#ifndef QUIET
if (internal->opts.verbose > 1) {
if (writing) {
uint64_t written_bytes = bytes ();
double written_mb = written_bytes / (double) (1 << 20);
MSG ("after writing %" PRIu64 " bytes %.1f MB", written_bytes,
written_mb);
if (close_file == 3) {
size_t actual_bytes = size (name ());
if (actual_bytes) {
double actual_mb = actual_bytes / (double) (1 << 20);
MSG ("deflated to %zd bytes %.1f MB", actual_bytes, actual_mb);
MSG ("factor %.2f (%.2f%% compression)",
relative (written_bytes, actual_bytes),
percent (actual_bytes, written_bytes));
} else
MSG ("but could not determine actual size of written file");
}
} else {
uint64_t read_bytes = bytes ();
double read_mb = read_bytes / (double) (1 << 20);
MSG ("after reading %" PRIu64 " bytes %.1f MB", read_bytes, read_mb);
if (close_file == 2) {
size_t actual_bytes = size (name ());
double actual_mb = actual_bytes / (double) (1 << 20);
MSG ("inflated from %zd bytes %.1f MB", actual_bytes, actual_mb);
MSG ("factor %.2f (%.2f%% compression)",
relative (read_bytes, actual_bytes),
percent (actual_bytes, read_bytes));
}
}
}
#endif
}
void File::flush () {
assert (file);
fflush (file);
}
File::~File () {
if (file)
close ();
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/file.hpp 0000664 0000000 0000000 00000012114 14501267155 0016107 0 ustar 00root root 0000000 0000000 #ifndef _file_hpp_INCLUDED
#define _file_hpp_INCLUDED
#include
#include
#include
#include
#ifndef NDEBUG
#include
#endif
/*------------------------------------------------------------------------*/
#ifndef NUNLOCKED
#define cadical_putc_unlocked putc_unlocked
#define cadical_getc_unlocked getc_unlocked
#else
#define cadical_putc_unlocked putc
#define cadical_getc_unlocked getc
#endif
/*------------------------------------------------------------------------*/
namespace CaDiCaL {
// Wraps a 'C' file 'FILE' with name and supports zipped reading and writing
// through 'popen' using external helper tools. Reading has line numbers.
// Compression and decompression relies on external utilities, e.g., 'gzip',
// 'bzip2', 'xz', and '7z', which should be in the 'PATH'.
struct Internal;
class File {
#ifndef QUIET
Internal *internal;
#endif
#if !defined(QUIET) || !defined(NDEBUG)
bool writing;
#endif
int close_file; // need to close file (1=fclose, 2=pclose, 3=pipe)
int child_pid;
FILE *file;
const char *_name;
uint64_t _lineno;
uint64_t _bytes;
File (Internal *, bool, int, int, FILE *, const char *);
static FILE *open_file (Internal *, const char *path, const char *mode);
static FILE *read_file (Internal *, const char *path);
static FILE *write_file (Internal *, const char *path);
static void split_str (const char *, std::vector &);
static void delete_str_vector (std::vector &);
static FILE *open_pipe (Internal *, const char *fmt, const char *path,
const char *mode);
static FILE *read_pipe (Internal *, const char *fmt, const int *sig,
const char *path);
#ifndef __WIN32
static FILE *write_pipe (Internal *, const char *fmt, const char *path,
int &child_pid);
#endif
public:
static char *find_program (const char *prg); // search in 'PATH'
static bool exists (const char *path); // file exists?
static bool writable (const char *path); // can write to that file?
static size_t size (const char *path); // file size in bytes
// Does the file match the file type signature.
//
static bool match (Internal *, const char *path, const int *sig);
// Read from existing file. Assume given name.
//
static File *read (Internal *, FILE *f, const char *name);
// Open file from path name for reading (possibly through opening a pipe
// to a decompression utility, based on the suffix).
//
static File *read (Internal *, const char *path);
// Same for writing as for reading above.
//
static File *write (Internal *, FILE *, const char *name);
static File *write (Internal *, const char *path);
~File ();
// Using the 'unlocked' versions here is way faster but
// not thread safe if the same file is used by different
// threads, which on the other hand currently is impossible.
int get () {
assert (!writing);
int res = cadical_getc_unlocked (file);
if (res == '\n')
_lineno++;
if (res != EOF)
_bytes++;
return res;
}
bool put (char ch) {
assert (writing);
if (cadical_putc_unlocked (ch, file) == EOF)
return false;
_bytes++;
return true;
}
bool put (unsigned char ch) {
assert (writing);
if (cadical_putc_unlocked (ch, file) == EOF)
return false;
_bytes++;
return true;
}
bool put (const char *s) {
for (const char *p = s; *p; p++)
if (!put (*p))
return false;
return true;
}
bool put (int lit) {
assert (writing);
if (!lit)
return put ('0');
else if (lit == -2147483648) {
assert (lit == INT_MIN);
return put ("-2147483648");
} else {
char buffer[11];
int i = sizeof buffer;
buffer[--i] = 0;
assert (lit != INT_MIN);
unsigned idx = abs (lit);
while (idx) {
assert (i > 0);
buffer[--i] = '0' + idx % 10;
idx /= 10;
}
if (lit < 0 && !put ('-'))
return false;
return put (buffer + i);
}
}
bool put (int64_t l) {
assert (writing);
if (!l)
return put ('0');
else if (l == INT64_MIN) {
assert (sizeof l == 8);
return put ("-9223372036854775808");
} else {
char buffer[21];
int i = sizeof buffer;
buffer[--i] = 0;
assert (l != INT64_MIN);
uint64_t k = l < 0 ? -l : l;
while (k) {
assert (i > 0);
buffer[--i] = '0' + k % 10;
k /= 10;
}
if (l < 0 && !put ('-'))
return false;
return put (buffer + i);
}
}
bool put (uint64_t l) {
assert (writing);
if (!l)
return put ('0');
else {
char buffer[22];
int i = sizeof buffer;
buffer[--i] = 0;
while (l) {
assert (i > 0);
buffer[--i] = '0' + l % 10;
l /= 10;
}
return put (buffer + i);
}
}
const char *name () const { return _name; }
uint64_t lineno () const { return _lineno; }
uint64_t bytes () const { return _bytes; }
bool closed () { return !file; }
void close ();
void flush ();
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/flags.cpp 0000664 0000000 0000000 00000005666 14501267155 0016275 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
void Internal::mark_fixed (int lit) {
if (external_prop && !external_prop_is_lazy && observed (lit)) {
int elit = externalize (lit);
assert (elit && external->observed (elit));
external->propagator->notify_assignment (elit, true);
// Does not increase the notified counter because
// it is a separated way of notification.
}
Flags &f = flags (lit);
assert (f.status == Flags::ACTIVE);
f.status = Flags::FIXED;
LOG ("fixed %d", abs (lit));
stats.all.fixed++;
stats.now.fixed++;
stats.inactive++;
assert (stats.active);
stats.active--;
assert (!active (lit));
assert (f.fixed ());
}
void Internal::mark_eliminated (int lit) {
Flags &f = flags (lit);
assert (f.status == Flags::ACTIVE);
f.status = Flags::ELIMINATED;
LOG ("eliminated %d", abs (lit));
stats.all.eliminated++;
stats.now.eliminated++;
stats.inactive++;
assert (stats.active);
stats.active--;
assert (!active (lit));
assert (f.eliminated ());
}
void Internal::mark_pure (int lit) {
Flags &f = flags (lit);
assert (f.status == Flags::ACTIVE);
f.status = Flags::PURE;
LOG ("pure %d", abs (lit));
stats.all.pure++;
stats.now.pure++;
stats.inactive++;
assert (stats.active);
stats.active--;
assert (!active (lit));
assert (f.pure ());
}
void Internal::mark_substituted (int lit) {
Flags &f = flags (lit);
assert (f.status == Flags::ACTIVE);
f.status = Flags::SUBSTITUTED;
LOG ("substituted %d", abs (lit));
stats.all.substituted++;
stats.now.substituted++;
stats.inactive++;
assert (stats.active);
stats.active--;
assert (!active (lit));
assert (f.substituted ());
}
void Internal::mark_active (int lit) {
Flags &f = flags (lit);
assert (f.status == Flags::UNUSED);
f.status = Flags::ACTIVE;
LOG ("activate %d previously unused", abs (lit));
assert (stats.inactive);
stats.inactive--;
assert (stats.unused);
stats.unused--;
stats.active++;
assert (active (lit));
}
void Internal::reactivate (int lit) {
assert (!active (lit));
Flags &f = flags (lit);
assert (f.status != Flags::FIXED);
assert (f.status != Flags::UNUSED);
#ifdef LOGGING
const char *msg = 0;
#endif
switch (f.status) {
default:
case Flags::ELIMINATED:
assert (f.status == Flags::ELIMINATED);
assert (stats.now.eliminated > 0);
stats.now.eliminated--;
#ifdef LOGGING
msg = "eliminated";
#endif
break;
case Flags::SUBSTITUTED:
#ifdef LOGGING
msg = "substituted";
#endif
assert (stats.now.substituted > 0);
stats.now.substituted--;
break;
case Flags::PURE:
#ifdef LOGGING
msg = "pure literal";
#endif
assert (stats.now.pure > 0);
stats.now.pure--;
break;
}
#ifdef LOGGING
assert (msg);
LOG ("reactivate previously %s %d", msg, abs (lit));
#endif
f.status = Flags::ACTIVE;
assert (active (lit));
stats.reactivated++;
assert (stats.inactive > 0);
stats.inactive--;
stats.active++;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/flags.hpp 0000664 0000000 0000000 00000005035 14501267155 0016270 0 ustar 00root root 0000000 0000000 #ifndef _flags_hpp_INCLUDED
#define _flags_hpp_INCLUDED
namespace CaDiCaL {
struct Flags { // Variable flags.
// The first set of flags is related to 'analyze' and 'minimize'.
//
bool seen : 1; // seen in generating first UIP clause in 'analyze'
bool keep : 1; // keep in learned clause in 'minimize'
bool poison : 1; // can not be removed in 'minimize'
bool removable : 1; // can be removed in 'minimize'
bool shrinkable : 1; // can be removed in 'shrink'
bool added : 1; // has already been added to lrat_chain (in 'minimize')
bool ignorepos : 1; // decompose need to dif between pos/neg lit
bool ignoreneg : 1; // decompose
// These three variable flags are used to schedule clauses in subsumption
// ('subsume'), variables in bounded variable elimination ('elim') and in
// hyper ternary resolution ('ternary').
//
bool elim : 1; // removed since last 'elim' round (*)
bool subsume : 1; // added since last 'subsume' round (*)
bool ternary : 1; // added in ternary clause since last 'ternary' (*)
unsigned char decompose : 2; // generate correct lrat chains in decompose
// These literal flags are used by blocked clause elimination ('block').
//
unsigned char block : 2; // removed since last 'block' round (*)
unsigned char skip : 2; // skip this literal as blocking literal
// Bits for handling assumptions.
//
unsigned char assumed : 2;
unsigned char failed : 2;
enum {
UNUSED = 0,
ACTIVE = 1,
FIXED = 2,
ELIMINATED = 3,
SUBSTITUTED = 4,
PURE = 5
};
unsigned char status : 3;
// Initialized explicitly in 'Internal::init' through this function.
//
Flags () {
seen = keep = poison = removable = shrinkable = added = false;
subsume = elim = ternary = true;
block = 3u;
skip = assumed = failed = decompose = 0;
status = UNUSED;
}
bool unused () const { return status == UNUSED; }
bool active () const { return status == ACTIVE; }
bool fixed () const { return status == FIXED; }
bool eliminated () const { return status == ELIMINATED; }
bool substituted () const { return status == SUBSTITUTED; }
bool pure () const { return status == PURE; }
// The flags marked with '(*)' are copied during 'External::copy_flags',
// which in essence means they are reset in the copy if they were clear.
// This avoids the effort of fruitless preprocessing the copy.
void copy (Flags &dst) const {
dst.elim = elim;
dst.subsume = subsume;
dst.ternary = ternary;
dst.block = block;
}
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/flip.cpp 0000664 0000000 0000000 00000013220 14501267155 0016114 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
bool Internal::flip (int lit) {
// Do not try to flip inactive literals except for unused variables.
if (!active (lit) && !flags (lit).unused ())
return false;
// Need to reestablish proper watching invariants as if there are no
// blocking literals as flipping in principle does not work with them.
if (propergated < trail.size ())
propergate ();
LOG ("trying to flip %d", lit);
const int idx = vidx (lit);
const signed char original_value = vals[idx];
assert (original_value);
lit = original_value < 0 ? -idx : idx;
assert (val (lit) > 0);
// Here we go over all the clauses in which 'lit' is watched by 'lit' and
// check whether assigning 'lit' to false would break watching invariants
// or even make the clause false. We also try to find replacement
// watches in case this fixes the watching invariant. This code is very
// similar to propagation of a literal in 'Internal::propagate'.
bool res = true;
Watches &ws = watches (lit);
const const_watch_iterator eow = ws.end ();
watch_iterator bow = ws.begin ();
// We first go over binary watches/clauses first as this is cheaper and
// has higher chance of failure and we can not use blocking literals.
for (const_watch_iterator i = bow; i != eow; i++) {
const Watch w = *i;
if (!w.binary ())
continue;
const signed char b = val (w.blit);
if (b > 0)
continue;
assert (b < 0);
res = false;
break;
}
if (res) {
const_watch_iterator i = bow;
watch_iterator j = bow;
while (i != eow) {
const Watch w = *j++ = *i++;
if (w.binary ())
continue;
if (w.clause->garbage) {
j--;
continue;
}
literal_iterator lits = w.clause->begin ();
const int other = lits[0] ^ lits[1] ^ lit;
const signed char u = val (other);
if (u > 0)
continue;
const int size = w.clause->size;
const literal_iterator middle = lits + w.clause->pos;
const const_literal_iterator end = lits + size;
literal_iterator k = middle;
int r = 0;
signed char v = -1;
while (k != end && (v = val (r = *k)) < 0)
k++;
if (v < 0) {
k = lits + 2;
assert (w.clause->pos <= size);
while (k != middle && (v = val (r = *k)) < 0)
k++;
}
if (v < 0) {
res = false;
break;
}
assert (v > 0);
assert (lits + 2 <= k), assert (k <= w.clause->end ());
w.clause->pos = k - lits;
lits[0] = other, lits[1] = r, *k = lit;
watch_literal (r, lit, w.clause);
j--;
}
if (j != i) {
while (i != eow)
*j++ = *i++;
ws.resize (j - ws.begin ());
}
}
#ifdef LOGGING
if (res)
LOG ("literal %d can be flipped", lit);
else
LOG ("literal %d can not be flipped", lit);
#endif
if (res) {
const int idx = vidx (lit);
const signed char original_value = vals[idx];
assert (original_value);
lit = original_value < 0 ? -idx : idx;
assert (val (lit) > 0);
LOG ("flipping value of %d = 1 to %d = -1", lit, lit);
vals[idx] = -original_value;
vals[-idx] = original_value;
assert (val (-lit) > 0);
assert (val (lit) < 0);
Var &v = var (idx);
assert (trail[v.trail] == lit);
trail[v.trail] = -lit;
} else
LOG ("flipping value of %d failed", lit);
return res;
}
bool Internal::flippable (int lit) {
// Can not check inactive literals except for unused variables.
if (!active (lit) && !flags (lit).unused ())
return false;
// Need to reestablish proper watching invariants as if there are no
// blocking literals as flipping in principle does not work with them.
if (propergated < trail.size ())
propergate ();
LOG ("checking whether %d is flippable", lit);
const int idx = vidx (lit);
const signed char original_value = vals[idx];
assert (original_value);
lit = original_value < 0 ? -idx : idx;
assert (val (lit) > 0);
// Here we go over all the clauses in which 'lit' is watched by 'lit' and
// check whether assigning 'lit' to false would break watching invariants
// or even make the clause false. In contrast to 'flip' we do not try to
// find replacement literals but do use blocking literals'. Therefore we
// also do not split the traversal code into two parts.
bool res = true;
Watches &ws = watches (lit);
const const_watch_iterator eow = ws.end ();
for (watch_iterator i = ws.begin (); i != eow; i++) {
const Watch w = *i;
const signed char b = val (w.blit);
if (b > 0)
continue;
assert (b < 0);
if (w.binary ()) {
res = false;
break;
}
if (w.clause->garbage)
continue;
literal_iterator lits = w.clause->begin ();
const int other = lits[0] ^ lits[1] ^ lit;
const signed char u = val (other);
if (u > 0) {
i->blit = other;
continue;
}
const int size = w.clause->size;
const literal_iterator middle = lits + w.clause->pos;
const const_literal_iterator end = lits + size;
literal_iterator k = middle;
int r = 0;
signed char v = -1;
while (k != end && (v = val (r = *k)) < 0)
k++;
if (v < 0) {
k = lits + 2;
assert (w.clause->pos <= size);
while (k != middle && (v = val (r = *k)) < 0)
k++;
}
if (v < 0) {
res = false;
break;
}
assert (v > 0);
assert (lits + 2 <= k);
assert (k <= w.clause->end ());
w.clause->pos = k - lits;
i->blit = r;
}
#ifdef LOGGING
if (res)
LOG ("literal %d can be flipped", lit);
else
LOG ("literal %d can not be flipped", lit);
#endif
return res;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/format.cpp 0000664 0000000 0000000 00000003446 14501267155 0016463 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
void Format::enlarge () {
char *old = buffer;
buffer = new char[size = size ? 2 * size : 1];
memcpy (buffer, old, count);
delete[] old;
}
inline void Format::push_char (char ch) {
if (size == count)
enlarge ();
buffer[count++] = ch;
}
void Format::push_string (const char *s) {
char ch;
while ((ch = *s++))
push_char (ch);
}
void Format::push_int (int d) {
char tmp[16];
snprintf (tmp, sizeof tmp, "%d", d);
push_string (tmp);
}
void Format::push_uint64 (uint64_t u) {
char tmp[16];
snprintf (tmp, sizeof tmp, "%" PRIu64, u);
push_string (tmp);
}
static bool match_format (const char *&str, const char *pattern) {
assert (pattern);
const char *p = str;
const char *q = pattern;
while (*q)
if (*q++ != *p++)
return false;
str = p;
return true;
}
const char *Format::add (const char *fmt, va_list &ap) {
const char *p = fmt;
char ch;
while ((ch = *p++)) {
if (ch != '%')
push_char (ch);
else if (*p == 'c')
push_char (va_arg (ap, int)), p++;
else if (*p == 'd')
push_int (va_arg (ap, int)), p++;
else if (*p == 's')
push_string (va_arg (ap, const char *)), p++;
else if (match_format (p, PRIu64))
push_uint64 (va_arg (ap, uint64_t));
else {
push_char ('%');
push_char (*p);
break;
} // unsupported
}
push_char (0);
count--; // thus automatic append in subsequent calls.
return buffer;
}
const char *Format::init (const char *fmt, ...) {
count = 0;
va_list ap;
va_start (ap, fmt);
const char *res = add (fmt, ap);
va_end (ap);
return res;
}
const char *Format::append (const char *fmt, ...) {
va_list ap;
va_start (ap, fmt);
const char *res = add (fmt, ap);
va_end (ap);
return res;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/format.hpp 0000664 0000000 0000000 00000001545 14501267155 0016466 0 ustar 00root root 0000000 0000000 #ifndef _format_hpp_INCLUDED
#define _format_hpp_INCLUDED
#include
namespace CaDiCaL {
// This class provides a 'printf' style formatting utility.
// Only '%c', '%d', '%s' are supported at this point.
// It is used to capture and save an error message.
class Format {
char *buffer;
int64_t count, size;
void enlarge ();
void push_char (char);
void push_string (const char *);
void push_int (int);
void push_uint64 (uint64_t);
const char *add (const char *fmt, va_list &);
public:
Format () : buffer (0), count (0), size (0) {}
~Format () {
if (buffer)
delete[] buffer;
}
const char *init (const char *fmt, ...) CADICAL_ATTRIBUTE_FORMAT (2, 3);
const char *append (const char *fmt, ...) CADICAL_ATTRIBUTE_FORMAT (2, 3);
operator const char * () const { return count ? buffer : 0; }
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/gates.cpp 0000664 0000000 0000000 00000045312 14501267155 0016274 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// As in our original SATeLite published at SAT'05 we are trying to find
// gates in order to restrict the number of resolutions that need to be
// tried. If there is such a gate, we only need to consider resolvents
// among gate and one non-gate clauses. Resolvents between definitions will
// be tautological anyhow and resolvents among non-gates can actually be
// shown to be redundant too.
/*------------------------------------------------------------------------*/
// The next function returns a non-zero if the clause 'c', which is assumed
// to contain the literal 'first', after removing falsified literals is a
// binary clause. Then the actual second literal is returned.
int Internal::second_literal_in_binary_clause (Eliminator &eliminator,
Clause *c, int first) {
assert (!c->garbage);
int second = 0;
for (const auto &lit : *c) {
if (lit == first)
continue;
const signed char tmp = val (lit);
if (tmp < 0)
continue;
if (tmp > 0) {
mark_garbage (c);
elim_update_removed_clause (eliminator, c);
return 0;
}
if (second) {
second = INT_MIN;
break;
}
second = lit;
}
if (!second)
return 0;
if (second == INT_MIN)
return 0;
assert (active (second));
#ifdef LOGGING
if (c->size == 2)
LOG (c, "found binary");
else
LOG (c, "found actual binary %d %d", first, second);
#endif
return second;
}
/*------------------------------------------------------------------------*/
// need a copy from above that does not care about garbage
int Internal::second_literal_in_binary_clause_lrat (Clause *c, int first) {
// TODO: this seems to work
if (c->garbage)
return 0;
int second = 0;
for (const auto &lit : *c) {
if (lit == first)
continue;
const signed char tmp = val (lit);
if (!tmp) {
if (second) {
second = INT_MIN;
break;
}
second = lit;
}
}
if (!second)
return 0;
if (second == INT_MIN)
return 0;
return second;
}
// I needed to find the second clause for hyper unary resultion to build
// lrat this is not efficient but I could not find a better way then just
// finding the corresponding clause in all possible clauses
//
Clause *Internal::find_binary_clause (int first, int second) {
int best = first;
int other = second;
if (occs (first).size () > occs (second).size ()) {
best = second;
other = first;
}
for (auto c : occs (best))
if (second_literal_in_binary_clause_lrat (c, best) == other)
return c;
return 0;
}
/*------------------------------------------------------------------------*/
// Mark all other literals in binary clauses with 'first'. During this
// marking we might also detect hyper unary resolvents producing a unit.
// If such a unit is found we propagate it and return immediately.
void Internal::mark_binary_literals (Eliminator &eliminator, int first) {
if (unsat)
return;
if (val (first))
return;
if (!eliminator.gates.empty ())
return;
assert (!marked (first));
assert (eliminator.marked.empty ());
const Occs &os = occs (first);
for (const auto &c : os) {
if (c->garbage)
continue;
const int second =
second_literal_in_binary_clause (eliminator, c, first);
if (!second)
continue;
const int tmp = marked (second);
if (tmp < 0) {
// had a bug where units could occur multiple times here
// solved with flags
LOG ("found binary resolved unit %d", first);
if (opts.lrat && !opts.lratexternal) {
Clause *d = find_binary_clause (first, -second);
assert (d);
for (auto &lit : *d) {
if (lit == first || lit == -second)
continue;
assert (val (lit) < 0);
Flags &f = flags (lit);
if (f.seen)
continue;
analyzed.push_back (lit);
f.seen = true;
const unsigned uidx = vlit (-lit);
uint64_t id = unit_clauses[uidx];
assert (id);
lrat_chain.push_back (id);
// LOG ("gates added id %" PRId64, id);
}
for (auto &lit : *c) {
if (lit == first || lit == second)
continue;
assert (val (lit) < 0);
Flags &f = flags (lit);
if (f.seen)
continue;
analyzed.push_back (lit);
f.seen = true;
const unsigned uidx = vlit (-lit);
uint64_t id = unit_clauses[uidx];
assert (id);
lrat_chain.push_back (id);
// LOG ("gates added id %" PRId64, id);
}
lrat_chain.push_back (c->id);
lrat_chain.push_back (d->id);
// LOG ("gates added id %" PRId64, c->id);
// LOG ("gates added id %" PRId64, d->id);
clear_analyzed_literals ();
}
assign_unit (first);
elim_propagate (eliminator, first);
return;
}
if (tmp > 0) {
LOG (c, "duplicated actual binary clause");
elim_update_removed_clause (eliminator, c);
mark_garbage (c);
continue;
}
eliminator.marked.push_back (second);
mark (second);
LOG ("marked second literal %d in binary clause %d %d", second, first,
second);
}
}
// Unmark all literals saved on the 'marked' stack.
void Internal::unmark_binary_literals (Eliminator &eliminator) {
LOG ("unmarking %zd literals", eliminator.marked.size ());
for (const auto &lit : eliminator.marked)
unmark (lit);
eliminator.marked.clear ();
}
/*------------------------------------------------------------------------*/
// Find equivalence for 'pivot'. Requires that all other literals in binary
// clauses with 'pivot' are marked (through 'mark_binary_literals');
void Internal::find_equivalence (Eliminator &eliminator, int pivot) {
if (!opts.elimequivs)
return;
assert (opts.elimsubst);
if (unsat)
return;
if (val (pivot))
return;
if (!eliminator.gates.empty ())
return;
mark_binary_literals (eliminator, pivot);
if (unsat || val (pivot))
goto DONE;
for (const auto &c : occs (-pivot)) {
if (c->garbage)
continue;
const int second =
second_literal_in_binary_clause (eliminator, c, -pivot);
if (!second)
continue;
const int tmp = marked (second);
if (tmp > 0) {
LOG ("found binary resolved unit %d", second);
// did not find a bug where units could occur multiple times here
// still solved potential issues with flags
if (opts.lrat && !opts.lratexternal) {
Clause *d = find_binary_clause (pivot, second);
assert (d);
for (auto &lit : *d) {
if (lit == pivot || lit == second)
continue;
assert (val (lit) < 0);
Flags &f = flags (lit);
if (f.seen)
continue;
analyzed.push_back (lit);
f.seen = true;
const unsigned uidx = vlit (-lit);
uint64_t id = unit_clauses[uidx];
assert (id);
lrat_chain.push_back (id);
// LOG ("gates added id %" PRId64, id);
}
for (auto &lit : *c) {
if (lit == -pivot || lit == second)
continue;
assert (val (lit) < 0);
Flags &f = flags (lit);
if (f.seen)
continue;
analyzed.push_back (lit);
f.seen = true;
const unsigned uidx = vlit (-lit);
uint64_t id = unit_clauses[uidx];
assert (id);
lrat_chain.push_back (id);
// LOG ("gates added id %" PRId64, id);
}
lrat_chain.push_back (c->id);
lrat_chain.push_back (d->id);
clear_analyzed_literals ();
// LOG ("gates added id %" PRId64, c->id);
// LOG ("gates added id %" PRId64, d->id);
}
assign_unit (second);
elim_propagate (eliminator, second);
if (val (pivot))
break;
if (unsat)
break;
}
if (tmp >= 0)
continue;
LOG ("found equivalence %d = %d", pivot, -second);
stats.elimequivs++;
stats.elimgates++;
LOG (c, "first gate clause");
assert (!c->gate);
c->gate = true;
eliminator.gates.push_back (c);
Clause *d = 0;
const Occs &ps = occs (pivot);
for (const auto &e : ps) {
if (e->garbage)
continue;
const int other =
second_literal_in_binary_clause (eliminator, e, pivot);
if (other == -second) {
d = e;
break;
}
}
assert (d);
LOG (d, "second gate clause");
assert (!d->gate);
d->gate = true;
eliminator.gates.push_back (d);
break;
}
DONE:
unmark_binary_literals (eliminator);
}
/*------------------------------------------------------------------------*/
// Find and gates for 'pivot' with a long clause, in which the pivot occurs
// positively. Requires that all other literals in binary clauses with
// 'pivot' are marked (through 'mark_binary_literals');
void Internal::find_and_gate (Eliminator &eliminator, int pivot) {
if (!opts.elimands)
return;
assert (opts.elimsubst);
if (unsat)
return;
if (val (pivot))
return;
if (!eliminator.gates.empty ())
return;
mark_binary_literals (eliminator, pivot);
if (unsat || val (pivot))
goto DONE;
for (const auto &c : occs (-pivot)) {
if (c->garbage)
continue;
if (c->size < 3)
continue;
bool all_literals_marked = true;
unsigned arity = 0;
int satisfied = 0;
for (const auto &lit : *c) {
if (lit == -pivot)
continue;
assert (lit != pivot);
signed char tmp = val (lit);
if (tmp < 0)
continue;
if (tmp > 0) {
satisfied = lit;
break;
}
tmp = marked (lit);
if (tmp < 0) {
arity++;
continue;
}
all_literals_marked = false;
break;
}
if (!all_literals_marked)
continue;
if (satisfied) {
LOG (c, "satisfied by %d candidate base clause", satisfied);
mark_garbage (c);
continue;
}
#ifdef LOGGING
if (opts.log) {
Logger::print_log_prefix (this);
tout.magenta ();
printf ("found arity %u AND gate %d = ", arity, -pivot);
bool first = true;
for (const auto &lit : *c) {
if (lit == -pivot)
continue;
assert (lit != pivot);
if (!first)
fputs (" & ", stdout);
printf ("%d", -lit);
first = false;
}
fputc ('\n', stdout);
tout.normal ();
fflush (stdout);
}
#endif
stats.elimands++;
stats.elimgates++;
(void) arity;
assert (!c->gate);
c->gate = true;
eliminator.gates.push_back (c);
for (const auto &lit : *c) {
if (lit == -pivot)
continue;
assert (lit != pivot);
signed char tmp = val (lit);
if (tmp < 0)
continue;
assert (!tmp);
assert (marked (lit) < 0);
marks[vidx (lit)] *= 2;
}
unsigned count = 0;
for (const auto &d : occs (pivot)) {
if (d->garbage)
continue;
const int other =
second_literal_in_binary_clause (eliminator, d, pivot);
if (!other)
continue;
const int tmp = marked (other);
if (tmp != 2)
continue;
LOG (d, "AND gate binary side clause");
assert (!d->gate);
d->gate = true;
eliminator.gates.push_back (d);
count++;
}
assert (count >= arity);
(void) count;
break;
}
DONE:
unmark_binary_literals (eliminator);
}
/*------------------------------------------------------------------------*/
// Find and extract ternary clauses.
bool Internal::get_ternary_clause (Clause *d, int &a, int &b, int &c) {
if (d->garbage)
return false;
if (d->size < 3)
return false;
int found = 0;
a = b = c = 0;
for (const auto &lit : *d) {
if (val (lit))
continue;
if (++found == 1)
a = lit;
else if (found == 2)
b = lit;
else if (found == 3)
c = lit;
else
return false;
}
return found == 3;
}
// This function checks whether 'd' exists as ternary clause.
bool Internal::match_ternary_clause (Clause *d, int a, int b, int c) {
if (d->garbage)
return false;
int found = 0;
for (const auto &lit : *d) {
if (val (lit))
continue;
if (a != lit && b != lit && c != lit)
return false;
found++;
}
return found == 3;
}
Clause *Internal::find_ternary_clause (int a, int b, int c) {
if (occs (b).size () > occs (c).size ())
swap (b, c);
if (occs (a).size () > occs (b).size ())
swap (a, b);
for (auto d : occs (a))
if (match_ternary_clause (d, a, b, c))
return d;
return 0;
}
/*------------------------------------------------------------------------*/
// Find if-then-else gate.
void Internal::find_if_then_else (Eliminator &eliminator, int pivot) {
if (!opts.elimites)
return;
assert (opts.elimsubst);
if (unsat)
return;
if (val (pivot))
return;
if (!eliminator.gates.empty ())
return;
const Occs &os = occs (pivot);
const auto end = os.end ();
for (auto i = os.begin (); i != end; i++) {
Clause *di = *i;
int ai, bi, ci;
if (!get_ternary_clause (di, ai, bi, ci))
continue;
if (bi == pivot)
swap (ai, bi);
if (ci == pivot)
swap (ai, ci);
assert (ai == pivot);
for (auto j = i + 1; j != end; j++) {
Clause *dj = *j;
int aj, bj, cj;
if (!get_ternary_clause (dj, aj, bj, cj))
continue;
if (bj == pivot)
swap (aj, bj);
if (cj == pivot)
swap (aj, cj);
assert (aj == pivot);
if (abs (bi) == abs (cj))
swap (bj, cj);
if (abs (ci) == abs (cj))
continue;
if (bi != -bj)
continue;
Clause *d1 = find_ternary_clause (-pivot, bi, -ci);
if (!d1)
continue;
Clause *d2 = find_ternary_clause (-pivot, bj, -cj);
if (!d2)
continue;
LOG (di, "1st if-then-else");
LOG (dj, "2nd if-then-else");
LOG (d1, "3rd if-then-else");
LOG (d2, "4th if-then-else");
LOG ("found ITE gate %d == (%d ? %d : %d)", pivot, -bi, -ci, -cj);
assert (!di->gate);
assert (!dj->gate);
assert (!d1->gate);
assert (!d2->gate);
di->gate = true;
dj->gate = true;
d1->gate = true;
d2->gate = true;
eliminator.gates.push_back (di);
eliminator.gates.push_back (dj);
eliminator.gates.push_back (d1);
eliminator.gates.push_back (d2);
stats.elimgates++;
stats.elimites++;
return;
}
}
}
/*------------------------------------------------------------------------*/
// Find and extract clause.
bool Internal::get_clause (Clause *c, vector &l) {
if (c->garbage)
return false;
l.clear ();
for (const auto &lit : *c) {
if (val (lit))
continue;
l.push_back (lit);
}
return true;
}
// Check whether 'c' contains only the literals in 'l'.
bool Internal::is_clause (Clause *c, const vector &lits) {
if (c->garbage)
return false;
int size = lits.size ();
if (c->size < size)
return false;
int found = 0;
for (const auto &lit : *c) {
if (val (lit))
continue;
const auto it = find (lits.begin (), lits.end (), lit);
if (it == lits.end ())
return false;
if (++found > size)
return false;
}
return found == size;
}
Clause *Internal::find_clause (const vector &lits) {
int best = 0;
size_t len = 0;
for (const auto &lit : lits) {
size_t l = occs (lit).size ();
if (best && l >= len)
continue;
len = l, best = lit;
}
for (auto c : occs (best))
if (is_clause (c, lits))
return c;
return 0;
}
void Internal::find_xor_gate (Eliminator &eliminator, int pivot) {
if (!opts.elimxors)
return;
assert (opts.elimsubst);
if (unsat)
return;
if (val (pivot))
return;
if (!eliminator.gates.empty ())
return;
vector lits;
for (auto d : occs (pivot)) {
if (!get_clause (d, lits))
continue;
const int size = lits.size (); // clause size
const int arity = size - 1; // arity of XOR
if (size < 3)
continue;
if (arity > opts.elimxorlim)
continue;
assert (eliminator.gates.empty ());
unsigned needed = (1u << arity) - 1; // additional clauses
unsigned signs = 0; // literals to negate
do {
const unsigned prev = signs;
while (parity (++signs))
;
for (int j = 0; j < size; j++) {
const unsigned bit = 1u << j;
int lit = lits[j];
if ((prev & bit) != (signs & bit))
lits[j] = lit = -lit;
}
Clause *e = find_clause (lits);
if (!e)
break;
eliminator.gates.push_back (e);
} while (--needed);
if (needed) {
eliminator.gates.clear ();
continue;
}
eliminator.gates.push_back (d);
assert (eliminator.gates.size () == (1u << arity));
#ifdef LOGGING
if (opts.log) {
Logger::print_log_prefix (this);
tout.magenta ();
printf ("found arity %u XOR gate %d = ", arity, -pivot);
bool first = true;
for (const auto &lit : *d) {
if (lit == pivot)
continue;
assert (lit != -pivot);
if (!first)
fputs (" ^ ", stdout);
printf ("%d", lit);
first = false;
}
fputc ('\n', stdout);
tout.normal ();
fflush (stdout);
}
#endif
stats.elimgates++;
stats.elimxors++;
const auto end = eliminator.gates.end ();
auto j = eliminator.gates.begin ();
for (auto i = j; i != end; i++) {
Clause *e = *i;
if (e->gate)
continue;
e->gate = true;
LOG (e, "contributing");
*j++ = e;
}
eliminator.gates.resize (j - eliminator.gates.begin ());
break;
}
}
/*------------------------------------------------------------------------*/
// Find a gate for 'pivot'. If such a gate is found, the gate clauses are
// marked and pushed on the stack of gates. Further hyper unary resolution
// might detect units, which are propagated. This might assign the pivot or
// even produce the empty clause.
void Internal::find_gate_clauses (Eliminator &eliminator, int pivot) {
if (!opts.elimsubst)
return;
if (unsat)
return;
if (val (pivot))
return;
assert (eliminator.gates.empty ());
find_equivalence (eliminator, pivot);
find_and_gate (eliminator, pivot);
find_and_gate (eliminator, -pivot);
find_if_then_else (eliminator, pivot);
find_xor_gate (eliminator, pivot);
}
void Internal::unmark_gate_clauses (Eliminator &eliminator) {
LOG ("unmarking %zd gate clauses", eliminator.gates.size ());
for (const auto &c : eliminator.gates) {
assert (c->gate);
c->gate = false;
}
eliminator.gates.clear ();
}
/*------------------------------------------------------------------------*/
} // namespace CaDiCaL
cadical-rel-1.7.4/src/heap.hpp 0000664 0000000 0000000 00000012745 14501267155 0016117 0 ustar 00root root 0000000 0000000 #ifndef _heap_hpp_INCLUDED
#define _heap_hpp_INCLUDED
#include "util.hpp" // Alphabetically after 'heap.hpp'.
namespace CaDiCaL {
using namespace std;
// This is a priority queue with updates for unsigned integers implemented
// as binary heap. We need to map integer elements added (through
// 'push_back') to positions on the binary heap in 'array'. This map is
// stored in the 'pos' array. This approach is really wasteful (at least in
// terms of memory) if only few and a sparse set of integers is added. So
// it should not be used in this situation. A generic priority queue would
// implement the mapping externally provided by another template parameter.
// Since we use 'UINT_MAX' as 'not contained' flag, we can only have
// 'UINT_MAX - 1' elements in the heap.
const unsigned invalid_heap_position = UINT_MAX;
template class heap {
vector array; // actual binary heap
vector pos; // positions of elements in array
C less; // less-than for elements
// Map an element to its position entry in the 'pos' map.
//
unsigned &index (unsigned e) {
if (e >= pos.size ())
pos.resize (1 + (size_t) e, invalid_heap_position);
unsigned &res = pos[e];
assert (res == invalid_heap_position || (size_t) res < array.size ());
return res;
}
bool has_parent (unsigned e) { return index (e) > 0; }
bool has_left (unsigned e) {
return (size_t) 2 * index (e) + 1 < size ();
}
bool has_right (unsigned e) {
return (size_t) 2 * index (e) + 2 < size ();
}
unsigned parent (unsigned e) {
assert (has_parent (e));
return array[(index (e) - 1) / 2];
}
unsigned left (unsigned e) {
assert (has_left (e));
return array[2 * index (e) + 1];
}
unsigned right (unsigned e) {
assert (has_right (e));
return array[2 * index (e) + 2];
}
// Exchange elements 'a' and 'b' in 'array' and fix their positions.
//
void exchange (unsigned a, unsigned b) {
unsigned &i = index (a), &j = index (b);
swap (array[i], array[j]);
swap (i, j);
}
// Bubble up an element as far as necessary.
//
void up (unsigned e) {
unsigned p;
while (has_parent (e) && less ((p = parent (e)), e))
exchange (p, e);
}
// Bubble down an element as far as necessary.
//
void down (unsigned e) {
while (has_left (e)) {
unsigned c = left (e);
if (has_right (e)) {
unsigned r = right (e);
if (less (c, r))
c = r;
}
if (!less (e, c))
break;
exchange (e, c);
}
}
// Very expensive checker for the main 'heap' invariant. Can be enabled
// to find violations of antisymmetry in the client implementation of
// 'less' and as well of course bugs in this heap implementation. It
// should be enabled during testing applications of the heap.
//
void check () {
#if 0 // EXPENSIVE HEAP CHECKING IF ENABLED
#warning "expensive checking in heap enabled"
assert (array.size () <= invalid_heap_position);
for (size_t i = 0; i < array.size (); i++) {
size_t l = 2*i + 1, r = 2*i + 2;
if (l < array.size ()) assert (!less (array[i], array[l]));
if (r < array.size ()) assert (!less (array[i], array[r]));
assert (array[i] >= 0);
{
assert ((size_t) array[i] < pos.size ());
assert (i == (size_t) pos[array[i]]);
}
}
for (size_t i = 0; i < pos.size (); i++) {
if (pos[i] == invalid_heap_position) continue;
assert (pos[i] < array.size ());
assert (array[pos[i]] == (unsigned) i);
}
#endif
}
public:
heap (const C &c) : less (c) {}
// Number of elements in the heap.
//
size_t size () const { return array.size (); }
// Check if no more elements are in the heap.
//
bool empty () const { return array.empty (); }
// Check whether 'e' is already in the heap.
//
bool contains (unsigned e) const {
if ((size_t) e >= pos.size ())
return false;
return pos[e] != invalid_heap_position;
}
// Add a new (not contained) element 'e' to the heap.
//
void push_back (unsigned e) {
assert (!contains (e));
size_t i = array.size ();
assert (i < (size_t) invalid_heap_position);
array.push_back (e);
index (e) = (unsigned) i;
up (e);
down (e);
check ();
}
// Returns the maximum element in the heap.
//
unsigned front () const {
assert (!empty ());
return array[0];
}
// Removes the maximum element in the heap.
//
unsigned pop_front () {
assert (!empty ());
unsigned res = array[0], last = array.back ();
if (size () > 1)
exchange (res, last);
index (res) = invalid_heap_position;
array.pop_back ();
if (size () > 1)
down (last);
check ();
return res;
}
// Notify the heap, that evaluation of 'less' has changed for 'e'.
//
void update (unsigned e) {
assert (contains (e));
up (e);
down (e);
check ();
}
void clear () {
array.clear ();
pos.clear ();
}
void erase () {
erase_vector (array);
erase_vector (pos);
}
void shrink () {
shrink_vector (array);
shrink_vector (pos);
}
// Standard iterators 'inherited' from 'vector'.
//
typedef typename vector::iterator iterator;
typedef typename vector::const_iterator const_iterator;
iterator begin () { return array.begin (); }
iterator end () { return array.end (); }
const_iterator begin () const { return array.begin (); }
const_iterator end () const { return array.end (); }
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/instantiate.cpp 0000664 0000000 0000000 00000024706 14501267155 0017520 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
// This provides an implementation of variable instantiation, a technique
// for removing literals with few occurrence (see also 'instantiate.hpp').
/*------------------------------------------------------------------------*/
// Triggered at the end of a variable elimination round ('elim_round').
void Internal::collect_instantiation_candidates (
Instantiator &instantiator) {
assert (occurring ());
for (auto idx : vars) {
if (frozen (idx))
continue;
if (!active (idx))
continue;
if (flags (idx).elim)
continue; // BVE attempt pending
for (int sign = -1; sign <= 1; sign += 2) {
const int lit = sign * idx;
if (noccs (lit) > opts.instantiateocclim)
continue;
Occs &os = occs (lit);
for (const auto &c : os) {
if (c->garbage)
continue;
if (opts.instantiateonce && c->instantiated)
continue;
if (c->size < opts.instantiateclslim)
continue;
bool satisfied = false;
int unassigned = 0;
for (const auto &other : *c) {
const signed char tmp = val (other);
if (tmp > 0)
satisfied = true;
if (!tmp)
unassigned++;
}
if (satisfied)
continue;
if (unassigned < 3)
continue; // avoid learning units
size_t negoccs = occs (-lit).size ();
LOG (c,
"instantiation candidate literal %d "
"with %zu negative occurrences in",
lit, negoccs);
instantiator.candidate (lit, c, c->size, negoccs);
}
}
}
}
/*------------------------------------------------------------------------*/
// Specialized propagation and assignment routines for instantiation.
inline void Internal::inst_assign (int lit) {
LOG ("instantiate assign %d", lit);
assert (!val (lit));
vals[lit] = 1;
vals[-lit] = -1;
trail.push_back (lit);
}
// Conflict analysis is only needed to do valid resolution proofs.
// We remember propagated clauses in order of assignment (in inst_chain)
// which allows us to do a variant of conflict analysis if the instatiation
// attempt succeeds.
//
bool Internal::inst_propagate () { // Adapted from 'propagate'.
START (propagate);
int64_t before = propagated;
bool ok = true;
while (ok && propagated != trail.size ()) {
const int lit = -trail[propagated++];
LOG ("instantiate propagating %d", -lit);
Watches &ws = watches (lit);
const const_watch_iterator eow = ws.end ();
const_watch_iterator i = ws.begin ();
watch_iterator j = ws.begin ();
while (i != eow) {
const Watch w = *j++ = *i++;
const signed char b = val (w.blit);
if (b > 0)
continue;
if (w.binary ()) {
if (b < 0) {
ok = false;
LOG (w.clause, "conflict");
if (opts.lrat && !opts.lratexternal) {
inst_chain.push_back (w.clause);
}
break;
} else {
if (opts.lrat && !opts.lratexternal) {
inst_chain.push_back (w.clause);
}
inst_assign (w.blit);
}
} else {
literal_iterator lits = w.clause->begin ();
const int other = lits[0] ^ lits[1] ^ lit;
lits[0] = other, lits[1] = lit;
const signed char u = val (other);
if (u > 0)
j[-1].blit = other;
else {
const int size = w.clause->size;
const const_literal_iterator end = lits + size;
const literal_iterator middle = lits + w.clause->pos;
literal_iterator k = middle;
signed char v = -1;
int r = 0;
while (k != end && (v = val (r = *k)) < 0)
k++;
if (v < 0) {
k = lits + 2;
assert (w.clause->pos <= size);
while (k != middle && (v = val (r = *k)) < 0)
k++;
}
w.clause->pos = k - lits;
assert (lits + 2 <= k), assert (k <= w.clause->end ());
if (v > 0) {
j[-1].blit = r;
} else if (!v) {
LOG (w.clause, "unwatch %d in", r);
lits[1] = r;
*k = lit;
watch_literal (r, lit, w.clause);
j--;
} else if (!u) {
assert (v < 0);
if (opts.lrat && !opts.lratexternal) {
inst_chain.push_back (w.clause);
}
inst_assign (other);
} else {
assert (u < 0);
assert (v < 0);
if (opts.lrat && !opts.lratexternal) {
inst_chain.push_back (w.clause);
}
LOG (w.clause, "conflict");
ok = false;
break;
}
}
}
}
if (j != i) {
while (i != eow)
*j++ = *i++;
ws.resize (j - ws.begin ());
}
}
int64_t delta = propagated - before;
stats.propagations.instantiate += delta;
STOP (propagate);
return ok;
}
/*------------------------------------------------------------------------*/
// This is the instantiation attempt.
bool Internal::instantiate_candidate (int lit, Clause *c) {
stats.instried++;
if (c->garbage)
return false;
assert (!level);
bool found = false, satisfied = false, inactive = false;
int unassigned = 0;
for (const auto &other : *c) {
if (other == lit)
found = true;
const signed char tmp = val (other);
if (tmp > 0) {
satisfied = true;
break;
}
if (!tmp && !active (other)) {
inactive = true;
break;
}
if (!tmp)
unassigned++;
}
if (!found)
return false;
if (inactive)
return false;
if (satisfied)
return false;
if (unassigned < 3)
return false;
size_t before = trail.size ();
assert (propagated == before);
assert (active (lit));
assert (inst_chain.empty ());
LOG (c, "trying to instantiate %d in", lit);
assert (!c->garbage);
c->instantiated = true;
assert (lrat_chain.empty ());
level++;
inst_assign (lit); // Assume 'lit' to true.
for (const auto &other : *c) {
if (other == lit)
continue;
const signed char tmp = val (other);
if (tmp) {
assert (tmp < 0);
continue;
}
inst_assign (-other); // Assume other to false.
}
bool ok = inst_propagate (); // Propagate.
assert (lrat_chain.empty ()); // chain will be built here
if (ok) {
inst_chain.clear ();
} else if (opts.lrat && !opts.lratexternal) { // analyze conflict for lrat
assert (inst_chain.size ());
Clause *reason = inst_chain.back ();
inst_chain.pop_back ();
lrat_chain.push_back (reason->id);
for (const auto &other : *reason) {
Flags &f = flags (other);
assert (!f.seen);
f.seen = true;
analyzed.push_back (other);
}
}
while (trail.size () > before) { // Backtrack.
const int other = trail.back ();
LOG ("instantiate unassign %d", other);
trail.pop_back ();
assert (val (other) > 0);
vals[other] = vals[-other] = 0;
// this is a variant of conflict analysis which is only needed for lrat
if (!ok && inst_chain.size () && opts.lrat && !opts.lratexternal) {
Flags &f = flags (other);
if (f.seen) {
Clause *reason = inst_chain.back ();
lrat_chain.push_back (reason->id);
for (const auto &other : *reason) {
Flags &f = flags (other);
if (f.seen)
continue;
f.seen = true;
analyzed.push_back (other);
}
f.seen = false;
}
inst_chain.pop_back ();
}
}
assert (inst_chain.empty ());
// post processing step for lrat
if (!ok && opts.lrat && !opts.lratexternal) {
if (flags (lit).seen)
lrat_chain.push_back (c->id);
for (const auto &other : *c) {
Flags &f = flags (other);
f.seen = false;
}
for (int other : analyzed) {
Flags &f = flags (other);
if (!f.seen) {
f.seen = true;
continue;
}
const unsigned uidx = vlit (-other);
uint64_t id = unit_clauses[uidx];
assert (id);
lrat_chain.push_back (id);
}
clear_analyzed_literals ();
reverse (lrat_chain.begin (), lrat_chain.end ());
}
assert (analyzed.empty ());
propagated = before;
assert (level == 1);
level = 0;
if (ok) {
assert (lrat_chain.empty ());
LOG ("instantiation failed");
return false;
}
unwatch_clause (c);
LOG (lrat_chain, "instantiate proof chain");
strengthen_clause (c, lit);
watch_clause (c);
lrat_chain.clear ();
assert (c->size > 1);
LOG ("instantiation succeeded");
stats.instantiated++;
return true;
}
/*------------------------------------------------------------------------*/
// Try to instantiate all candidates collected before through the
// 'collect_instantiation_candidates' routine.
void Internal::instantiate (Instantiator &instantiator) {
assert (opts.instantiate);
START (instantiate);
stats.instrounds++;
#ifndef QUIET
const int64_t candidates = instantiator.candidates.size ();
int64_t tried = 0;
#endif
int64_t instantiated = 0;
init_watches ();
connect_watches ();
if (propagated < trail.size ()) {
if (!propagate ()) {
LOG ("propagation after connecting watches failed");
learn_empty_clause ();
assert (unsat);
}
}
PHASE ("instantiate", stats.instrounds,
"attempting to instantiate %" PRId64
" candidate literal clause pairs",
candidates);
while (!unsat && !terminated_asynchronously () &&
!instantiator.candidates.empty ()) {
Instantiator::Candidate cand = instantiator.candidates.back ();
instantiator.candidates.pop_back ();
#ifndef QUIET
tried++;
#endif
if (!active (cand.lit))
continue;
LOG (cand.clause,
"trying to instantiate %d with "
"%zd negative occurrences in",
cand.lit, cand.negoccs);
if (!instantiate_candidate (cand.lit, cand.clause))
continue;
instantiated++;
VERBOSE (2,
"instantiation %" PRId64 " (%.1f%%) succeeded "
"(%.1f%%) with %zd negative occurrences in size %d clause",
tried, percent (tried, candidates),
percent (instantiated, tried), cand.negoccs, cand.size);
}
PHASE ("instantiate", stats.instrounds,
"instantiated %" PRId64 " candidate successfully "
"out of %" PRId64 " tried %.1f%%",
instantiated, tried, percent (instantiated, tried));
report ('I', !instantiated);
reset_watches ();
STOP (instantiate);
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/instantiate.hpp 0000664 0000000 0000000 00000002427 14501267155 0017521 0 ustar 00root root 0000000 0000000 #ifndef _instantiate_hpp_INCLUDED
#define _instantiate_hpp_INCLUDED
namespace CaDiCaL {
// We are trying to remove literals in clauses, which occur in few clauses
// and further restrict this removal to variables for which variable
// elimination failed. Thus if for instance we succeed in removing the
// single occurrence of a literal, pure literal elimination can
// eliminate the corresponding variable in the next variable elimination
// round. The set of such literal clause candidate pairs is collected at
// the end of a variable elimination round and tried before returning. The
// name of this technique is inspired by 'variable instantiation' as
// described in [AnderssonBjesseCookHanna-DAC'02] and apparently
// successfully used in the 'Oepir' SAT solver.
struct Clause;
struct Internal;
class Instantiator {
friend struct Internal;
struct Candidate {
int lit;
int size;
size_t negoccs;
Clause *clause;
Candidate (int l, Clause *c, int s, size_t n)
: lit (l), size (s), negoccs (n), clause (c) {}
};
vector candidates;
public:
void candidate (int l, Clause *c, int s, size_t n) {
candidates.push_back (Candidate (l, c, s, n));
}
operator bool () const { return !candidates.empty (); }
};
} // namespace CaDiCaL
#endif
cadical-rel-1.7.4/src/internal.cpp 0000664 0000000 0000000 00000061551 14501267155 0017010 0 ustar 00root root 0000000 0000000 #include "internal.hpp"
namespace CaDiCaL {
/*------------------------------------------------------------------------*/
static Clause external_reason_clause;
Internal::Internal ()
: mode (SEARCH), unsat (false), iterating (false),
localsearching (false), lookingahead (false), preprocessing (false),
protected_reasons (false), force_saved_phase (false),
searching_lucky_phases (false), stable (false), reported (false),
external_prop (false), did_external_prop (false),
external_prop_is_lazy (true), rephased (0), vsize (0), max_var (0),
clause_id (0), original_id (0), reserved_ids (0), conflict_id (0),
level (0), vals (0), score_inc (1.0), scores (this), conflict (0),
ignore (0), external_reason (&external_reason_clause), notified (0),
propagated (0), propagated2 (0), propergated (0), best_assigned (0),
target_assigned (0), no_conflict_until (0), unsat_constraint (false),
marked_failed (true), proof (0), checker (0), tracer (0),
lratchecker (0), lratbuilder (0), opts (this),
#ifndef QUIET
profiles (this), force_phase_messages (false),
#endif
arena (this), prefix ("c "), internal (this), external (0),
termination_forced (false), vars (this->max_var),
lits (this->max_var) {
control.push_back (Level (0, 0));
}
Internal::~Internal () {
for (const auto &c : clauses)
delete_clause (c);
if (proof)
delete proof;
if (tracer)
delete tracer;
if (checker)
delete checker;
if (lratchecker)
delete lratchecker;
if (lratbuilder)
delete lratbuilder;
if (vals) {
vals -= vsize;
delete[] vals;
}
}
/*------------------------------------------------------------------------*/
// Values in 'vals' can be accessed in the range '[-max_var,max_var]' that
// is directly by a literal. This is crucial for performance. By shifting
// the start of 'vals' appropriately, we achieve that negative offsets from
// the start of 'vals' can be used. We also need to set both values at
// 'lit' and '-lit' during assignments. In MiniSAT integer literals are
// encoded, using the least significant bit as negation. This avoids taking
// the 'abs ()' (as in our solution) and thus also avoids a branch in the
// hot-spot of the solver (clause traversal in propagation). That solution
// requires another (branch less) negation of the values though and
// debugging is harder since literals occur only encoded in clauses.
// The main draw-back of our solution is that we have to shift the memory
// and access it through negative indices, which looks less clean (but still
// as far I can tell is properly defined C / C++). You might get a warning
// by static analyzers though. Clang with '--analyze' thought that this
// idiom would generate a memory leak thus we use the following dummy.
static signed char *ignore_clang_analyze_memory_leak_warning;
void Internal::enlarge_vals (size_t new_vsize) {
signed char *new_vals;
const size_t bytes = 2u * new_vsize;
new_vals = new signed char[bytes]; // g++-4.8 does not like ... { 0 };
memset (new_vals, 0, bytes);
ignore_clang_analyze_memory_leak_warning = new_vals;
new_vals += new_vsize;
if (vals)
memcpy (new_vals - max_var, vals - max_var, 2u * max_var + 1u);
vals -= vsize;
delete[] vals;
vals = new_vals;
}
/*------------------------------------------------------------------------*/
template
static void enlarge_init (vector &v, size_t N, const T &i) {
if (v.size () < N)
v.resize (N, i);
}
template static void enlarge_only (vector &v, size_t N) {
if (v.size () < N)
v.resize (N, T ());
}
template static void enlarge_zero (vector &v, size_t N) {
enlarge_init (v, N, (const T &) 0);
}
/*------------------------------------------------------------------------*/
void Internal::enlarge (int new_max_var) {
assert (!level || external_prop);
size_t new_vsize = vsize ? 2 * vsize : 1 + (size_t) new_max_var;
while (new_vsize <= (size_t) new_max_var)
new_vsize *= 2;
LOG ("enlarge internal size from %zd to new size %zd", vsize, new_vsize);
// Ordered in the size of allocated memory (larger block first).
enlarge_zero (unit_clauses, 2 * new_vsize);
enlarge_only (wtab, 2 * new_vsize);
enlarge_only (vtab, new_vsize);
enlarge_zero (parents, new_vsize);
enlarge_only (links, new_vsize);
enlarge_zero (btab, new_vsize);
enlarge_zero (gtab, new_vsize);
enlarge_zero (stab, new_vsize);
enlarge_init (ptab, 2 * new_vsize, -1);
enlarge_only (ftab, new_vsize);
enlarge_vals (new_vsize);
enlarge_zero (frozentab, new_vsize);
enlarge_zero (relevanttab, new_vsize);
const signed char val = opts.phase ? 1 : -1;
enlarge_init (phases.saved, new_vsize, val);
enlarge_zero (phases.forced, new_vsize);
enlarge_zero (phases.target, new_vsize);
enlarge_zero (phases.best, new_vsize);
enlarge_zero (phases.prev, new_vsize);
enlarge_zero (phases.min, new_vsize);
enlarge_zero (marks, new_vsize);
vsize = new_vsize;
}
void Internal::init_vars (int new_max_var) {
if (new_max_var <= max_var)
return;
if (level && !external_prop)
backtrack ();
LOG ("initializing %d internal variables from %d to %d",
new_max_var - max_var, max_var + 1, new_max_var);
if ((size_t) new_max_var >= vsize)
enlarge (new_max_var);
#ifndef NDEBUG
for (int64_t i = -new_max_var; i < -max_var; i++)
assert (!vals[i]);
for (unsigned i = max_var + 1; i <= (unsigned) new_max_var; i++)
assert (!vals[i]), assert (!btab[i]), assert (!gtab[i]);
for (uint64_t i = 2 * ((uint64_t) max_var + 1);
i <= 2 * (uint64_t) new_max_var + 1; i++)
assert (ptab[i] == -1);
#endif
assert (!btab[0]);
int old_max_var = max_var;
max_var = new_max_var;
init_queue (old_max_var, new_max_var);
init_scores (old_max_var, new_max_var);
int initialized = new_max_var - old_max_var;
stats.vars += initialized;
stats.unused += initialized;
stats.inactive += initialized;
LOG ("finished initializing %d internal variables", initialized);
}
void Internal::add_original_lit (int lit) {
assert (abs (lit) <= max_var);
if (lit) {
original.push_back (lit);
} else {
const uint64_t id =
original_id < reserved_ids ? ++original_id : ++clause_id;
if (proof) {
// Use the external form of the clause for printing in proof
// Externalize(internalized literal) != external literal
assert (!original.size () || !external->eclause.empty ());
if (opts.lrat)
proof->add_external_original_clause (id, external->eclause);
else
proof->add_external_original_clause (id, external->eclause);
}
add_new_original_clause (id);
original.clear ();
}
}
/*------------------------------------------------------------------------*/
void Internal::reserve_ids (int number) {
// return;
assert (number >= 0);
assert (!clause_id && !reserved_ids && !original_id);
clause_id = reserved_ids = number;
if (proof)
proof->set_first_id (reserved_ids);
}
/*------------------------------------------------------------------------*/
// This is the main CDCL loop with interleaved inprocessing.
int Internal::cdcl_loop_with_inprocessing () {
int res = 0;
START (search);
if (stable) {
START (stable);
report ('[');
} else {
START (unstable);
report ('{');
}
while (!res) {
if (unsat)
res = 20;
else if (unsat_constraint)
res = 20;
else if (!propagate ())
analyze (); // propagate and analyze
else if (iterating)
iterate (); // report learned unit
else if (!external_propagate () || unsat) { // external propagation
if (unsat)
continue;
else
analyze ();
} else if (satisfied ()) { // found model
if (!external_check_solution () || unsat) {
if (unsat)
continue;
else
analyze ();
} else if (satisfied ())
res = 10;
} else if (search_limits_hit ())
break; // decision or conflict limit
else if (terminated_asynchronously ()) // externally terminated
break;
else if (restarting ())
restart (); // restart by backtracking
else if (rephasing ())
rephase (); // reset variable phases
else if (reducing ())
reduce (); // collect useless clauses
else if (probing ())
probe (); // failed literal probing
else if (subsuming ())
subsume (); // subsumption algorithm
else if (eliminating ())
elim (); // variable elimination
else if (compacting ())
compact (); // collect variables
else if (conditioning ())
condition (); // globally blocked clauses
else
res = decide (); // next decision
}
if (stable) {
STOP (stable);
report (']');
} else {
STOP (unstable);
report ('}');
}
STOP (search);
return res;
}
/*------------------------------------------------------------------------*/
// Most of the limits are only initialized in the first 'solve' call and
// increased as in a stand-alone non-incremental SAT call except for those
// explicitly marked as being reset below.
void Internal::init_report_limits () {
reported = false;
lim.report = 0;
}
void Internal::init_preprocessing_limits () {
const bool incremental = lim.initialized;
if (incremental)
LOG ("reinitializing preprocessing limits incrementally");
else
LOG ("initializing preprocessing limits and increments");
const char *mode = 0;
/*----------------------------------------------------------------------*/
if (incremental)
mode = "keeping";
else {
lim.subsume = stats.conflicts + scale (opts.subsumeint);
mode = "initial";
}
(void) mode;
LOG ("%s subsume limit %" PRId64 " after %" PRId64 " conflicts", mode,
lim.subsume, lim.subsume - stats.conflicts);
/*----------------------------------------------------------------------*/
if (incremental)
mode = "keeping";
else {
last.elim.marked = -1;
lim.elim = stats.conflicts + scale (opts.elimint);
mode = "initial";
}
(void) mode;
LOG ("%s elim limit %" PRId64 " after %" PRId64 " conflicts", mode,
lim.elim, lim.elim - stats.conflicts);
// Initialize and reset elimination bounds in any case.
lim.elimbound = opts.elimboundmin;
LOG ("elimination bound %" PRId64 "", lim.elimbound);
/*----------------------------------------------------------------------*/
if (!incremental) {
last.ternary.marked = -1; // TODO explain why this is necessary.
lim.compact = stats.conflicts + opts.compactint;
LOG ("initial compact limit %" PRId64 " increment %" PRId64 "",
lim.compact, lim.compact - stats.conflicts);
}
/*----------------------------------------------------------------------*/
if (incremental)
mode = "keeping";
else {
lim.probe = stats.conflicts + opts.probeint;
mode = "initial";
}
(void) mode;
LOG ("%s probe limit %" PRId64 " after %" PRId64 " conflicts", mode,
lim.probe, lim.probe - stats.conflicts);
/*----------------------------------------------------------------------*/
if (incremental)
mode = "keeping";
else {
lim.condition = stats.conflicts + opts.conditionint;
mode = "initial";
}
LOG ("%s condition limit %" PRId64 " increment %" PRId64, mode,
lim.condition, lim.condition - stats.conflicts);
/*----------------------------------------------------------------------*/
// Initial preprocessing rounds.
if (inc.preprocessing <= 0) {
lim.preprocessing = 0;
LOG ("no preprocessing");
} else {
lim.preprocessing = inc.preprocessing;
LOG ("limiting to %" PRId64 " preprocessing rounds", lim.preprocessing);
}
}
void Internal::init_search_limits () {
const bool incremental = lim.initialized;
if (incremental)
LOG ("reinitializing search limits incrementally");
else
LOG ("initializing search limits and increments");
const char *mode = 0;
/*----------------------------------------------------------------------*/
if (incremental)
mode = "keeping";
else {
last.reduce.conflicts = -1;
lim.reduce = stats.conflicts + opts.reduceint;
mode = "initial";
}
(void) mode;
LOG ("%s reduce limit %" PRId64 " after %" PRId64 " conflicts", mode,
lim.reduce, lim.reduce - stats.conflicts);
/*----------------------------------------------------------------------*/
if (incremental)
mode = "keeping";
else {
lim.flush = opts.flushint;
inc.flush = opts.flushint;
mode = "initial";
}
(void) mode;
LOG ("%s flush limit %" PRId64 " interval %" PRId64 "", mode, lim.flush,
inc.flush);
/*----------------------------------------------------------------------*/
// Initialize or reset 'rephase' limits in any case.
lim.rephase = stats.conflicts + opts.rephaseint;
lim.rephased[0] = lim.rephased[1] = 0;
LOG ("new rephase limit %" PRId64 " after %" PRId64 " conflicts",
lim.rephase, lim.rephase - stats.conflicts);
/*----------------------------------------------------------------------*/
// Initialize or reset 'restart' limits in any case.
lim.restart = stats.conflicts + opts.restartint;
LOG ("new restart limit %" PRId64 " increment %" PRId64 "", lim.restart,
lim.restart - stats.conflicts);
/*----------------------------------------------------------------------*/
if (!incremental) {
stable = opts.stabilize && opts.stabilizeonly;
if (stable)
LOG ("starting in always forced stable phase");
else
LOG ("starting in default non-stable phase");
init_averages ();
} else if (opts.stabilize && opts.stabilizeonly) {
LOG ("keeping always forced stable phase");
assert (stable);
} else if (stable) {
LOG ("switching back to default non-stable phase");
stable = false;
swap_averages ();
} else
LOG ("keeping non-stable phase");
inc.stabilize = opts.stabilizeint;
lim.stabilize = stats.conflicts + inc.stabilize;
LOG ("new stabilize limit %" PRId64 " after %" PRId64 " conflicts",
lim.stabilize, inc.stabilize);
if (opts.stabilize && opts.reluctant) {
LOG ("new restart reluctant doubling sequence period %d",
opts.reluctant);
reluctant.enable (opts.reluctant, opts.reluctantmax);
} else
reluctant.disable ();
/*----------------------------------------------------------------------*/
// Conflict and decision limits.
if (inc.conflicts < 0) {
lim.conflicts = -1;
LOG ("no limit on conflicts");
} else {
lim.conflicts = stats.conflicts + inc.conflicts;
LOG ("conflict limit after %" PRId64 " conflicts at %" PRId64
" conflicts",
inc.conflicts, lim.conflicts);
}
if (inc.decisions < 0) {
lim.decisions = -1;
LOG ("no limit on decisions");
} else {
lim.decisions = stats.decisions + inc.decisions;
LOG ("conflict limit after %" PRId64 " decisions at %" PRId64
" decisions",
inc.decisions, lim.decisions);
}
/*----------------------------------------------------------------------*/
// Initial preprocessing rounds.
if (inc.localsearch <= 0) {
lim.localsearch = 0;
LOG ("no local search");
} else {
lim.localsearch = inc.localsearch;
LOG ("limiting to %" PRId64 " local search rounds", lim.localsearch);
}
/*----------------------------------------------------------------------*/
lim.initialized = true;
}
/*------------------------------------------------------------------------*/
bool Internal::preprocess_round (int round) {
(void) round;
if (unsat)
return false;
if (!max_var)
return false;
START (preprocess);
struct {
int64_t vars, clauses;
} before, after;
before.vars = active ();
before.clauses = stats.current.irredundant;
stats.preprocessings++;
assert (!preprocessing);
preprocessing = true;
PHASE ("preprocessing", stats.preprocessings,
"starting round %d with %" PRId64 " variables and %" PRId64
" clauses",
round, before.vars, before.clauses);
int old_elimbound = lim.elimbound;
if (opts.probe)
probe (false);
if (opts.elim)
elim (false);
if (opts.condition)
condition (false);
after.vars = active ();
after.clauses = stats.current.irredundant;
assert (preprocessing);
preprocessing = false;
PHASE ("preprocessing", stats.preprocessings,
"finished round %d with %" PRId64 " variables and %" PRId64
" clauses",
round, after.vars, after.clauses);
STOP (preprocess);
report ('P');
if (unsat)
return false;
if (after.vars < before.vars)
return true;
if (old_elimbound < lim.elimbound)
return true;
return false;
}
int Internal::preprocess () {
for (int i = 0; i < lim.preprocessing; i++)
if (!preprocess_round (i))
break;
if (unsat)
return 20;
return 0;
}
/*------------------------------------------------------------------------*/
int Internal::try_to_satisfy_formula_by_saved_phases () {
LOG ("satisfying formula by saved phases");
assert (!level);
assert (!force_saved_phase);
assert (propagated == trail.size ());
force_saved_phase = true;
int res = 0;
while (!res) {
if (satisfied ()) {
LOG ("formula indeed satisfied by saved phases");
res = 10;
} else if (decide ()) {
LOG ("inconsistent assumptions with redundant clauses and phases");
res = 20;
} else if (!propagate ()) {
LOG ("saved phases do not satisfy redundant clauses");
assert (level > 0);
backtrack ();
conflict = 0; // ignore conflict
assert (!res);
break;
}
}
assert (force_saved_phase);
force_saved_phase = false;
return res;
}
/*------------------------------------------------------------------------*/
void Internal::produce_failed_assumptions () {
LOG ("producing failed assumptions");
assert (!level);
assert (!assumptions.empty ());
while (!unsat) {
assert (!satisfied ());
if (decide ())
break;
while (!unsat && !propagate ())
analyze ();
}
if (unsat)
LOG ("formula is actually unsatisfiable unconditionally");
else
LOG ("assumptions indeed failing");
}
/*------------------------------------------------------------------------*/
int Internal::local_search_round (int round) {
assert (round > 0);
if (unsat)
return false;
if (!max_var)
return false;
START_OUTER_WALK ();
assert (!localsearching);
localsearching = true;
// Determine propagation limit quadratically scaled with rounds.
//
int64_t limit = opts.walkmineff;
limit *= round;
if (LONG_MAX / round > limit)
limit *= round;
else
limit = LONG_MAX;
int res = walk_round (limit, true);
assert (localsearching);
localsearching = false;
STOP_OUTER_WALK ();
report ('L');
return res;
}
int Internal::local_search () {
if (unsat)
return 0;
if (!max_var)
return 0;
if (!opts.walk)
return 0;
if (constraint.size ())
return 0;
int res = 0;
for (int i = 1; !res && i <= lim.localsearch; i++)
res = local_search_round (i);
if (res == 10) {
LOG ("local search determined formula to be satisfiable");
assert (!stats.walk.minimum);
res = try_to_satisfy_formula_by_saved_phases ();
} else if (res == 20) {
LOG ("local search determined assumptions to be inconsistent");
assert (!assumptions.empty ());
produce_failed_assumptions ();
}
return res;
}
/*------------------------------------------------------------------------*/
int Internal::solve (bool preprocess_only) {
assert (clause.empty ());
START (solve);
if (preprocess_only)
LOG ("internal solving in preprocessing only mode");
else
LOG ("internal solving in full mode");
init_report_limits ();
int res = already_solved ();
if (!res)
res = restore_clauses ();
if (!res) {
init_preprocessing_limits ();
if (!preprocess_only)
init_search_limits ();
}
if (!res)
res = preprocess ();
if (!preprocess_only) {
if (!res)
res = local_search ();
if (!res)
res = lucky_phases ();
if (!res || (res == 10 && external_prop)) {
if (res == 10 && external_prop && level)
backtrack ();
res = cdcl_loop_with_inprocessing ();
}
}
finalize ();
reset_solving ();
report_solving (res);
STOP (solve);
return res;
}
int Internal::already_solved () {
int res = 0;
if (unsat || unsat_constraint) {
LOG ("already inconsistent");
res = 20;
} else {
if (level)
backtrack ();
if (!propagate ()) {
LOG ("root level propagation produces conflict");
learn_empty_clause ();
res = 20;
}
if (max_var == 0 && res == 0)
res = 10;
}
return res;
}
void Internal::report_solving (int res) {
if (res == 10)
report ('1');
else if (res == 20)
report ('0');
else
report ('?');
}
void Internal::reset_solving () {
if (termination_forced) {
// TODO this leads potentially to a data race if the external
// user is calling 'terminate' twice within one 'solve' call.
// A proper solution would be to guard / protect setting the
// 'termination_forced' flag and only allow it during solving and
// ignore it otherwise thus also the second time it is called during a
// 'solve' call. We could move resetting it also the start of
// 'solve'.
//
termination_forced = false;
LOG ("reset forced termination");
}
}
int Internal::restore_clauses () {
int res = 0;
if (opts.restoreall <= 1 && external->tainted.empty ()) {
LOG ("no tainted literals and nothing to restore");
report ('*');
} else {
report ('+');
external->restore_clauses ();
internal->report ('r');
if (!unsat && !propagate ()) {
LOG ("root level propagation after restore produces conflict");
learn_empty_clause ();
res = 20;
}
}
return res;
}
int Internal::lookahead () {
assert (clause.empty ());
START (lookahead);
assert (!lookingahead);
lookingahead = true;
int tmp = already_solved ();
if (!tmp)
tmp = restore_clauses ();
int res = 0;
if (!tmp)
res = lookahead_probing ();
if (res == INT_MIN)
res = 0;
reset_solving ();
report_solving (tmp);
assert (lookingahead);
lookingahead = false;
STOP (lookahead);
return res;
}
/*------------------------------------------------------------------------*/
void Internal::finalize () {
if (!proof)
return;
LOG ("finalizing");
// finalize external units
for (const auto &evar : external->vars) {
assert (evar > 0);
const auto eidx = 2 * evar;
int sign = 1;
uint64_t id = external->ext_units[eidx];
if (!id) {
sign = -1;
id = external->ext_units[eidx + 1];
}
if (id) {
proof->finalize_external_unit (id, evar * sign);
}
}
// finalize internal units
for (const auto &lit : lits) {
const auto elit = externalize (lit);
if (elit) {
const unsigned eidx = (elit < 0) + 2u * (unsigned) abs (elit);
const uint64_t id = external->ext_units[eidx];
if (id) {
assert (unit_clauses[vlit (lit)] == id);
continue;
}
}
const auto uidx = vlit (lit);
const uint64_t id = unit_clauses[uidx];
if (!id)
continue;
proof->finalize_unit (id, lit);
}
// See the discussion in 'propagate' on why garbage binary clauses stick
// around.
for (const auto &c : clauses)
if (!c->garbage || c->size == 2)
proof->finalize_clause (c);
// finalize conflict and proof
if (conflict_id)
proof->finalize_clause (conflict_id, {});
if (proof) {
proof->finalize_proof (conflict_id);
}
}
/*------------------------------------------------------------------------*/
void Internal::print_statistics () {
stats.print (this);
if (checker)
checker->print_stats ();
}
/*------------------------------------------------------------------------*/
// Only useful for debugging purposes.
void Internal::dump (Clause *c) {
for (const auto &lit : *c)
printf ("%d ", lit);
printf ("0\n");
}
void Internal::dump () {
int64_t m = assumptions.size ();
for (auto idx : vars)
if (fixed (idx))
m++;
for (const auto &c : clauses)
if (!c->garbage)
m++;
printf ("p cnf %d %" PRId64 "\n", max_var, m);
for (auto idx : vars) {
const int tmp = fixed (idx);
if (tmp)
printf ("%d 0\n", tmp < 0 ? -idx : idx);
}
for (const auto &c : clauses)
if (!c->garbage)
dump (c);
for (const auto &lit : assumptions)
printf ("%d 0\n", lit);
fflush (stdout);
}
/*------------------------------------------------------------------------*/
bool Internal::traverse_clauses (ClauseIterator &it) {
vector eclause;
if (unsat)
return it.clause (eclause);
for (const auto &c : clauses) {
if (c->garbage)
continue;
if (c->redundant)
continue;
bool satisfied = false;
for (const auto &ilit : *c) {
const int tmp = fixed (ilit);
if (tmp > 0) {
satisfied = true;
break;
}
if (tmp < 0)
continue;
const int elit = externalize (ilit);
eclause.push_back (elit);
}
if (!satisfied && !it.clause (eclause))
return false;
eclause.clear ();
}
return true;
}
} // namespace CaDiCaL
cadical-rel-1.7.4/src/internal.hpp 0000664 0000000 0000000 00000144421 14501267155 0017013 0 ustar 00root root 0000000 0000000 #ifndef _internal_hpp_INCLUDED
#define _internal_hpp_INCLUDED
/*------------------------------------------------------------------------*/
// Wrapped build specific headers which should go first.
#include "inttypes.hpp"
/*------------------------------------------------------------------------*/
// Common 'C' headers.
#include
#include
#include
#include
#include
#include
#include
#include
// Less common 'C' header.
extern "C" {
#include
}
/*------------------------------------------------------------------------*/
// Common 'C++' headers.
#include
#include
#include
#include
/*------------------------------------------------------------------------*/
// All internal headers are included here. This gives a nice overview on
// what is needed altogether. The 'Internal' class needs almost all the
// headers anyhow (since the idea is to avoid pointer references as much as
// possible). Most implementation files need to see the definition of the
// 'Internal' too. Thus there is no real advantage in trying to reduce the
// number of header files included here. The other benefit of having all
// header files here is that '.cpp' files then only need to include this.
#include "arena.hpp"
#include "averages.hpp"
#include "bins.hpp"
#include "block.hpp"
#include "cadical.hpp"
#include "checker.hpp"
#include "clause.hpp"
#include "config.hpp"
#include "contract.hpp"
#include "cover.hpp"
#include "decompose.hpp"
#include "elim.hpp"
#include "ema.hpp"
#include "external.hpp"
#include "file.hpp"
#include "flags.hpp"
#include "format.hpp"
#include "heap.hpp"
#include "instantiate.hpp"
#include "internal.hpp"
#include "level.hpp"
#include "limit.hpp"
#include "logging.hpp"
#include "lratbuilder.hpp"
#include "lratchecker.hpp"
#include "message.hpp"
#include "occs.hpp"
#include "options.hpp"
#include "parse.hpp"
#include "phases.hpp"
#include "profile.hpp"
#include "proof.hpp"
#include "queue.hpp"
#include "radix.hpp"
#include "random.hpp"
#include "range.hpp"
#include "reap.hpp"
#include "reluctant.hpp"
#include "resources.hpp"
#include "score.hpp"
#include "stats.hpp"
#include "terminal.hpp"
#include "tracer.hpp"
#include "util.hpp"
#include "var.hpp"
#include "version.hpp"
#include "vivify.hpp"
#include "watch.hpp"
/*------------------------------------------------------------------------*/
namespace CaDiCaL {
using namespace std;
struct Coveror;
struct External;
struct Walker;
struct CubesWithStatus {
int status = 0;
std::vector> cubes;
};
/*------------------------------------------------------------------------*/
struct Internal {
/*----------------------------------------------------------------------*/
// The actual internal state of the solver is set and maintained in this
// section. This is currently only used for debugging and testing.
enum Mode {
BLOCK = (1 << 0),
CONDITION = (1 << 1),
COVER = (1 << 2),
DECOMP = (1 << 3),
DEDUP = (1 << 4),
ELIM = (1 << 5),
LUCKY = (1 << 6),
PROBE = (1 << 7),
SEARCH = (1 << 8),
SIMPLIFY = (1 << 9),
SUBSUME = (1 << 10),
TERNARY = (1 << 11),
TRANSRED = (1 << 12),
VIVIFY = (1 << 13),
WALK = (1 << 14),
};
bool in_mode (Mode m) const { return (mode & m) != 0; }
void set_mode (Mode m) {
assert (!(mode & m));
mode |= m;
}
void reset_mode (Mode m) {
assert (mode & m);
mode &= ~m;
}
void require_mode (Mode m) const { assert (mode & m), (void) m; }
/*----------------------------------------------------------------------*/
int mode; // current internal state
bool unsat; // empty clause found or learned
bool iterating; // report learned unit ('i' line)
bool localsearching; // true during local search
bool lookingahead; // true during look ahead
bool preprocessing; // true during preprocessing
bool protected_reasons; // referenced reasons are protected
bool force_saved_phase; // force saved phase in decision
bool searching_lucky_phases; // during 'lucky_phases'
bool stable; // true during stabilization phase
bool reported; // reported in this solving call
bool external_prop; // true if an external propagator is connected
bool did_external_prop; // true if ext. propagation happened
bool external_prop_is_lazy; // true if the external propagator is lazy
char rephased; // last type of resetting phases
Reluctant reluctant; // restart counter in stable mode
size_t vsize; // actually allocated variable data size
int max_var; // internal maximum variable index
uint64_t clause_id; // last used id for clauses
uint64_t original_id; // ids for original clauses to produce lrat
uint64_t reserved_ids; // number of reserved ids for original clauses
uint64_t conflict_id; // store conflict id for finalize (frat)
vector unit_clauses; // keep track of unit_clauses (lrat/frat)
vector lrat_chain; // create lrat in solver: option lratdirect
vector mini_chain; // used to create lrat in minimize
vector minimize_chain; // used to create lrat in minimize
vector unit_chain; // used to avoid duplicate units
vector inst_chain; // for lrat in instantiate
vector>>
probehbr_chains; // only used if opts.probehbr=false
int level; // decision level ('control.size () - 1')
Phases phases; // saved, target and best phases
signed char *vals; // assignment [-max_var,max_var]
vector marks; // signed marks [1,max_var]
vector frozentab; // frozen counters [1,max_var]
vector i2e; // maps internal 'idx' to external 'lit'
vector relevanttab; // Reference counts for observed variables.
Queue queue; // variable move to front decision queue
Links links; // table of links for decision queue
double score_inc; // current score increment
ScoreSchedule scores; // score based decision priority queue
vector stab; // table of variable scores [1,max_var]
vector vtab; // variable table [1,max_var]
vector parents; // parent literals during probing
vector ftab; // variable and literal flags
vector btab; // enqueue time stamps for queue
vector gtab; // time stamp table to recompute glue
vector