diff --git a/README.md b/README.md index 0ed6cb8148..897dc66eaf 100644 --- a/README.md +++ b/README.md @@ -56,18 +56,19 @@ Only a few SMT solvers provide support for theories like Arrays, Floating Point, Currently JavaSMT supports several SMT solvers (see [Getting Started](doc/Getting-started.md) for installation): -| SMT Solver | Linux64 | Windows64 | MacOS | Description | -| --- |:---:|:---:|:---:|:--- | -| [Boolector](https://boolector.github.io/) | :heavy_check_mark: | | | a fast solver for bitvector logic, misses formula introspection | -| [CVC4](https://cvc4.github.io/) | :heavy_check_mark: | | | | -| [CVC5](https://cvc5.github.io/) | :heavy_check_mark: | | | new! | -| [MathSAT5](http://mathsat.fbk.eu/) | :heavy_check_mark: | :heavy_check_mark: | | | -| [OpenSMT](https://verify.inf.usi.ch/opensmt) | :heavy_check_mark: | | | new! | -| [OptiMathSAT](http://optimathsat.disi.unitn.it/) | :heavy_check_mark: | | | based on MathSAT5, with support for optimization | -| [Princess](http://www.philipp.ruemmer.org/princess.shtml) | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | Java-based SMT solver | -| [SMTInterpol](https://ultimate.informatik.uni-freiburg.de/smtinterpol/) | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | Java-based SMT solver | -| [Yices2](https://yices.csl.sri.com/) | :heavy_check_mark: | [soon](https://github.com/sosy-lab/java-smt/pull/215) | | | -| [Z3](https://github.com/Z3Prover/z3) | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | mature and well-known solver | +| SMT Solver | Linux64 | Windows64 | MacOS | Description | +|-------------------------------------------------------------------------|:---:|:---:|:---:|:-----------------------------------------------------------------------------| +| [Bitwuzla](https://boolector.github.io/) | :heavy_check_mark: | | | a fast solver for bitvector and floating-point logic, successor of Boolector | +| [Boolector](https://boolector.github.io/) | :heavy_check_mark: | | | a fast solver for bitvector logic, misses formula introspection | +| [CVC4](https://cvc4.github.io/) | :heavy_check_mark: | | | | +| [CVC5](https://cvc5.github.io/) | :heavy_check_mark: | | | new! | +| [MathSAT5](http://mathsat.fbk.eu/) | :heavy_check_mark: | :heavy_check_mark: | | | +| [OpenSMT](https://verify.inf.usi.ch/opensmt) | :heavy_check_mark: | | | new! | +| [OptiMathSAT](http://optimathsat.disi.unitn.it/) | :heavy_check_mark: | | | based on MathSAT5, with support for optimization | +| [Princess](http://www.philipp.ruemmer.org/princess.shtml) | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | Java-based SMT solver | +| [SMTInterpol](https://ultimate.informatik.uni-freiburg.de/smtinterpol/) | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | Java-based SMT solver | +| [Yices2](https://yices.csl.sri.com/) | :heavy_check_mark: | [soon](https://github.com/sosy-lab/java-smt/pull/215) | | | +| [Z3](https://github.com/Z3Prover/z3) | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | mature and well-known solver | The following features are supported (depending on the used SMT solver): diff --git a/build.xml b/build.xml index 2cb4a302ae..3a2d66ff2c 100644 --- a/build.xml +++ b/build.xml @@ -22,6 +22,7 @@ SPDX-License-Identifier: Apache-2.0 - + diff --git a/build/build-publish-solvers.xml b/build/build-publish-solvers.xml index b88aea311f..994a64a8d9 100644 --- a/build/build-publish-solvers.xml +++ b/build/build-publish-solvers.xml @@ -11,8 +11,9 @@ SPDX-License-Identifier: Apache-2.0 --> - + + diff --git a/build/build-publish-solvers/build-jar-yices2.xml b/build/build-publish-solvers/build-jar-yices2.xml index 1f9eaec4d2..9889600c47 100644 --- a/build/build-publish-solvers/build-jar-yices2.xml +++ b/build/build-publish-solvers/build-jar-yices2.xml @@ -25,7 +25,9 @@ SPDX-License-Identifier: Apache-2.0 - + + + diff --git a/build/build-publish-solvers/macros.xml b/build/build-publish-solvers/macros.xml index f7145604d8..e21696ab47 100644 --- a/build/build-publish-solvers/macros.xml +++ b/build/build-publish-solvers/macros.xml @@ -32,9 +32,10 @@ SPDX-License-Identifier: Apache-2.0 - + + message="Cannot publish without 'repository' dir, please run 'svn co https://svn.sosy-lab.org/software/ivy/repository/${ivy.organisation}/${ivy.module} repository/${ivy.organisation}/${ivy.module}'."/> You now want to run svn add repository/${ivy.organisation}/${ivy.module}/*-@{solverVersion}* - svn ci repository/${ivy.organisation}/${ivy.module} -m"publish version @{solverVersion} of @{solverName} Solver" - to make the new version publicly available. + svn ci repository/${ivy.organisation}/${ivy.module} -m"publish version + @{solverVersion} of @{solverName} Solver" + to make the new version publicly available. + diff --git a/build/build-publish-solvers/solver-bitwuzla.xml b/build/build-publish-solvers/solver-bitwuzla.xml new file mode 100644 index 0000000000..8673972f39 --- /dev/null +++ b/build/build-publish-solvers/solver-bitwuzla.xml @@ -0,0 +1,136 @@ + + + + + + + + + + + + + Please specify the path to Bitwuzla with the flag -Dbitwuzla.path=/path/to/bitwuzla. + The path has to point to the root Bitwuzla folder, i.e., + a checkout of the official git repositoy from 'https://github.com/bitwuzla/bitwuzla'. + Note that shell substitutions do not work and a full absolute path has to be specified. + + + The path is ${bitwuzla.path} + + + + Please specify a custom revision with the flag -Dbitwuzla.customRev=XXX. + The custom revision has to be unique amongst the already known version + numbers from the ivy repository. The script will append the git revision. + + + + Please specify the path to GMP with the flag -Dgmp.path=/path/to/gmp. + The path has to point to the root GMP folder with version equal to or larger than 6.1. + Note that shell substitutions do not work and a full absolute path has to be specified. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/build/build-publish-solvers/solver-boolector.xml b/build/build-publish-solvers/solver-boolector.xml index 7238058e43..97652d1319 100644 --- a/build/build-publish-solvers/solver-boolector.xml +++ b/build/build-publish-solvers/solver-boolector.xml @@ -30,7 +30,8 @@ SPDX-License-Identifier: Apache-2.0 - + @@ -39,56 +40,65 @@ SPDX-License-Identifier: Apache-2.0 - - + + - - - - - - + + + + + + - + - + - + - + - - + + + + + - - - + + + - + description="Publish Boolector binaries to Ivy repository."> + diff --git a/build/build-publish-solvers/solver-cvc4.xml b/build/build-publish-solvers/solver-cvc4.xml index 29a671396c..95c3ca349b 100644 --- a/build/build-publish-solvers/solver-cvc4.xml +++ b/build/build-publish-solvers/solver-cvc4.xml @@ -49,43 +49,54 @@ SPDX-License-Identifier: Apache-2.0 - + - + - + - + - - + + + + + - - - + + + + + + + + - - - + + + - + description="Publish CVC4 binaries to Ivy repository."> + diff --git a/build/build-publish-solvers/solver-cvc5.xml b/build/build-publish-solvers/solver-cvc5.xml index 430d78747f..bb1fe693cd 100644 --- a/build/build-publish-solvers/solver-cvc5.xml +++ b/build/build-publish-solvers/solver-cvc5.xml @@ -68,11 +68,12 @@ SPDX-License-Identifier: Apache-2.0 - + - + @@ -80,10 +81,13 @@ SPDX-License-Identifier: Apache-2.0 - - + + - + @@ -107,40 +111,57 @@ SPDX-License-Identifier: Apache-2.0 - - - + + + + + + + + - - + + + + + - - + + + + + - - + + + + + - + + + - + + - + description="Publish CVC5 binaries to Ivy repository."> + diff --git a/build/build-publish-solvers/solver-mathsat.xml b/build/build-publish-solvers/solver-mathsat.xml index cfabeb1b62..669925545d 100644 --- a/build/build-publish-solvers/solver-mathsat.xml +++ b/build/build-publish-solvers/solver-mathsat.xml @@ -30,54 +30,66 @@ SPDX-License-Identifier: Apache-2.0 - - + + - - - + + + - + - - - - - - - + + + + + + + - + Please specify the MathSAT5 version with the flag -Dmathsat.version=... . - - - + + + - + + description="Publish OptiMathSAT binaries to Ivy repo."> Please specify the @{flag} version with the flag -Dmathsat.version=... . - + - + diff --git a/build/build-publish-solvers/solver-opensmt.xml b/build/build-publish-solvers/solver-opensmt.xml index 2b73ffa905..cb950ffeae 100644 --- a/build/build-publish-solvers/solver-opensmt.xml +++ b/build/build-publish-solvers/solver-opensmt.xml @@ -30,7 +30,8 @@ SPDX-License-Identifier: Apache-2.0 - + @@ -39,9 +40,9 @@ SPDX-License-Identifier: Apache-2.0 - + - + @@ -71,8 +72,8 @@ SPDX-License-Identifier: Apache-2.0 - - + + @@ -175,8 +176,8 @@ SPDX-License-Identifier: Apache-2.0 - + description="Publish OpenSMT binaries to Ivy repository."> + diff --git a/build/build-publish-solvers/solver-z3.xml b/build/build-publish-solvers/solver-z3.xml index 1b5045aa81..15f991af2a 100644 --- a/build/build-publish-solvers/solver-z3.xml +++ b/build/build-publish-solvers/solver-z3.xml @@ -22,24 +22,32 @@ SPDX-License-Identifier: Apache-2.0 - Please specify the path to Z3 with the flag -Dz3.path=/path/to/z3 (e.g. `bin` directory). - The path has to point to the root Z3 folder (i.e., the path is ending with '/bin') and can be relative or absolute. + Please specify the path to Z3 with the flag -Dz3.path=/path/to/z3 (e.g. `bin` + directory). + The path has to point to the root Z3 folder (i.e., the path is ending with '/bin') and + can be relative or absolute. Note that shell substitutions do not work. - Please provide all releases (Linux64, MacOS, and Windows64) together in the same root directory, - e.g., copy the releases (especially the content of their `bin` directories) together into one directory. + Please provide all releases (Linux64, MacOS, and Windows64) together in the same root + directory, + e.g., copy the releases (especially the content of their `bin` directories) together + into one directory. The only overlap between those releases is the JAR file, which should be equal anyway. Additionally, make the Java sources available in this directory. This can be done by: - copying the content of sources-zip into the current directory (or vice versa) - - executing `python scripts/mk_make.py --java` to generate all Java related files. Executing `make` is not required. + - executing `python scripts/mk_make.py --java` to generate all Java related files. + Executing `make` is not required. - + - + + + libz3.so has missing SONAME property. Please run 'patchelf --set-soname libz3.so ${z3.path}/libz3.so'. @@ -59,40 +67,50 @@ SPDX-License-Identifier: Apache-2.0 - Please specify the path to Z3 with the flag -Dz3.path=/path/to/z3 (e.g. `bin` directory). + Please specify the path to Z3 with the flag -Dz3.path=/path/to/z3 (e.g. `bin` + directory). The path has to point to the root Z3 folder and can be relative or absolute. Note that shell substitutions do not work. - Please provide all releases (Linux64, MacOS, and Windows64) together in the same root directory, - e.g., copy the releases (especially the content of their `bin` directories) together into one directory. + Please provide all releases (Linux64, MacOS, and Windows64) together in the same root + directory, + e.g., copy the releases (especially the content of their `bin` directories) together + into one directory. The only overlap between those releases is the JAR file, which should be equal anyway. Additionally, make the Java sources available in this directory. This can be done by: - copying the content of sources-zip into the current directory (or vice versa) - - executing `python scripts/mk_make.py --java` to generate all Java related files. Executing `make` is not required. + - executing `python scripts/mk_make.py --java` to generate all Java related files. + Executing `make` is not required. - Option -Dz3.version=... not specified. Trying to determine z3.version from git repository. This will fail if git repository is not available. + Option -Dz3.version=... not specified. Trying to determine z3.version from git + repository. This will fail if git repository is not available. + - + - + description="Publish Z3 binaries to Ivy repo."> + - - - - + + + + - + @@ -107,15 +125,15 @@ SPDX-License-Identifier: Apache-2.0 + destdir="${z3.javadoc.dir}" + classpathref="classpath" + locale="en_US" + encoding="utf-8" + windowtitle="${z3.project.name}" + failonerror="false" + failonwarning="false" + overview="doc/javadoc_overview.html" + > @@ -131,7 +149,7 @@ SPDX-License-Identifier: Apache-2.0 - + diff --git a/build/build-publish-solvers/solvers-yices.xml b/build/build-publish-solvers/solvers-yices.xml index 998d7ea78c..7131d32bbb 100644 --- a/build/build-publish-solvers/solvers-yices.xml +++ b/build/build-publish-solvers/solvers-yices.xml @@ -16,42 +16,47 @@ SPDX-License-Identifier: Apache-2.0 + description="Compile Yices2 bindings"> - - - - - - - - - + + + + + + + + + + description="Publish Yices2 binaries to Ivy repo."> Please specify the Yices2 version with the flag -Dyices2.version=... . - + - + - + + description="Publish Java bindings for Yices2 to Ivy repo."> - + message="Cannot publish version ${version}, only unmodified working copies may be published."/> + diff --git a/build/build-publish.xml b/build/build-publish.xml index d71871ee2d..78799fd96b 100644 --- a/build/build-publish.xml +++ b/build/build-publish.xml @@ -25,8 +25,10 @@ SPDX-License-Identifier: Apache-2.0 + - Java wrapper for SMT solvers like Z3, MathSAT5, SMTInterpol, Princess, CVC4, CVC5, Boolector, and Yices2. + Java wrapper for SMT solvers like Z3, MathSAT5, SMTInterpol, Princess, CVC4, CVC5, + Boolector, Yices2, and Bitwuzla. @@ -41,6 +42,7 @@ SPDX-License-Identifier: Apache-2.0 + @@ -159,15 +161,18 @@ SPDX-License-Identifier: Apache-2.0 - + + - + + + + + + + Bitwuzla solver and JavaSMT JNI wrapper. + Bitwuzla is provided under the MIT License. + + + + + + + + + + + + + + + + + + + diff --git a/solvers_ivy_conf/ivy_javasmt_yices2.xml b/solvers_ivy_conf/ivy_javasmt_yices2.xml index f338b3a2c3..351bbcd4ee 100644 --- a/solvers_ivy_conf/ivy_javasmt_yices2.xml +++ b/solvers_ivy_conf/ivy_javasmt_yices2.xml @@ -33,19 +33,23 @@ SPDX-License-Identifier: Apache-2.0 - + - + - + - + diff --git a/src/org/sosy_lab/java_smt/SolverContextFactory.java b/src/org/sosy_lab/java_smt/SolverContextFactory.java index f5754b32ad..1f9e1387b6 100644 --- a/src/org/sosy_lab/java_smt/SolverContextFactory.java +++ b/src/org/sosy_lab/java_smt/SolverContextFactory.java @@ -29,6 +29,7 @@ import org.sosy_lab.java_smt.delegate.logging.LoggingSolverContext; import org.sosy_lab.java_smt.delegate.statistics.StatisticsSolverContext; import org.sosy_lab.java_smt.delegate.synchronize.SynchronizedSolverContext; +import org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaSolverContext; import org.sosy_lab.java_smt.solvers.boolector.BoolectorSolverContext; import org.sosy_lab.java_smt.solvers.cvc4.CVC4SolverContext; import org.sosy_lab.java_smt.solvers.cvc5.CVC5SolverContext; @@ -57,7 +58,8 @@ public enum Solvers { BOOLECTOR, CVC4, CVC5, - YICES2 + YICES2, + BITWUZLA } @Option(secure = true, description = "Export solver queries in SmtLib format into a file.") @@ -290,6 +292,10 @@ private SolverContext generateContext0(Solvers solverToCreate) case BOOLECTOR: return BoolectorSolverContext.create(config, shutdownNotifier, logfile, randomSeed, loader); + case BITWUZLA: + return BitwuzlaSolverContext.create( + config, shutdownNotifier, logfile, randomSeed, floatingPointRoundingMode, loader); + default: throw new AssertionError("no solver selected"); } diff --git a/src/org/sosy_lab/java_smt/api/BasicProverEnvironment.java b/src/org/sosy_lab/java_smt/api/BasicProverEnvironment.java index b5ac3b1455..75f56bdb12 100644 --- a/src/org/sosy_lab/java_smt/api/BasicProverEnvironment.java +++ b/src/org/sosy_lab/java_smt/api/BasicProverEnvironment.java @@ -197,7 +197,7 @@ interface AllSatCallback { * * @param propagator The (fresh) user propagator to register. * @return {@code true}, if the user propagator was successfully registered. Most SMT solvers do - * not support user propagators and hence return {@code false}. + * not support user propagators and hence return {@code false}. */ default boolean registerUserPropagator(UserPropagator propagator) { return false; diff --git a/src/org/sosy_lab/java_smt/api/BitvectorFormulaManager.java b/src/org/sosy_lab/java_smt/api/BitvectorFormulaManager.java index 48a3028de7..43d06203f9 100644 --- a/src/org/sosy_lab/java_smt/api/BitvectorFormulaManager.java +++ b/src/org/sosy_lab/java_smt/api/BitvectorFormulaManager.java @@ -145,7 +145,7 @@ public interface BitvectorFormulaManager { * the numerator itself. We refer to the SMTLIB standard for the division and modulo operators in * BV theory. * - * @param numerator dividend + * @param numerator dividend * @param denumerator divisor */ BitvectorFormula smodulo(BitvectorFormula numerator, BitvectorFormula denumerator); diff --git a/src/org/sosy_lab/java_smt/api/FloatingPointNumber.java b/src/org/sosy_lab/java_smt/api/FloatingPointNumber.java index a04f835590..3f5a9c3946 100644 --- a/src/org/sosy_lab/java_smt/api/FloatingPointNumber.java +++ b/src/org/sosy_lab/java_smt/api/FloatingPointNumber.java @@ -27,13 +27,19 @@ public abstract class FloatingPointNumber { public static final int DOUBLE_PRECISION_EXPONENT_SIZE = 11; public static final int DOUBLE_PRECISION_MANTISSA_SIZE = 52; - /** Whether the number is positive (TRUE) or negative (FALSE). */ + /** + * Whether the number is positive (TRUE) or negative (FALSE). + */ public abstract boolean getSign(); - /** The exponent of the floating-point number, given as numeric value. */ + /** + * The exponent of the floating-point number, given as numeric value. + */ public abstract BigInteger getExponent(); - /** The mantissa (aka significand) of the floating-point number, given as numeric value. */ + /** + * The mantissa (aka significand) of the floating-point number, given as numeric value. + */ public abstract BigInteger getMantissa(); public abstract int getExponentSize(); @@ -78,7 +84,9 @@ private boolean isDoublePrecision() { && getMantissaSize() == DOUBLE_PRECISION_MANTISSA_SIZE; } - /** compute a representation as Java-based float value, if possible. */ + /** + * compute a representation as Java-based float value, if possible. + */ public float floatValue() { Preconditions.checkArgument( isSinglePrecision(), @@ -88,7 +96,9 @@ public float floatValue() { return Float.intBitsToFloat(bits.length() == 0 ? 0 : (int) bits.toLongArray()[0]); } - /** compute a representation as Java-based double value, if possible. */ + /** + * compute a representation as Java-based double value, if possible. + */ public double doubleValue() { Preconditions.checkArgument( isSinglePrecision() || isDoublePrecision(), diff --git a/src/org/sosy_lab/java_smt/api/FunctionDeclarationKind.java b/src/org/sosy_lab/java_smt/api/FunctionDeclarationKind.java index c5932cd2eb..b69541dc81 100644 --- a/src/org/sosy_lab/java_smt/api/FunctionDeclarationKind.java +++ b/src/org/sosy_lab/java_smt/api/FunctionDeclarationKind.java @@ -138,7 +138,9 @@ public enum FunctionDeclarationKind { /** Unsigned remainder over bitvectors. */ BV_UREM, - /** Signed modulo over bitvectors. */ + /** + * Signed modulo over bitvectors. + */ BV_SMOD, /** Multiplication over bitvectors. */ diff --git a/src/org/sosy_lab/java_smt/api/PropagatorBackend.java b/src/org/sosy_lab/java_smt/api/PropagatorBackend.java index bbfa8f5d2c..7838d6ab09 100644 --- a/src/org/sosy_lab/java_smt/api/PropagatorBackend.java +++ b/src/org/sosy_lab/java_smt/api/PropagatorBackend.java @@ -47,7 +47,7 @@ public interface PropagatorBackend { * generate a theory lemma. * * @param assignedExpressions A set of assigned expressions. - * @param consequence The consequence implied by the assigned expressions. + * @param consequence The consequence implied by the assigned expressions. */ void propagateConsequence(BooleanFormula[] assignedExpressions, BooleanFormula consequence); @@ -56,11 +56,11 @@ public interface PropagatorBackend { * UserPropagator#onKnownValue}, will set the next decision to be made. If called during {@link * UserPropagator#onDecision}, will overwrite the current decision to be made. * - * @param expr The expression to assign to next. + * @param expr The expression to assign to next. * @param value The value to be assigned. If not given, the solver will decide. * @return False, if the value of {@code expr} is already assigned. True, otherwise. Note that the - * value of {@code expr} may already be decided before being reported via {@link - * UserPropagator#onKnownValue}. + * value of {@code expr} may already be decided before being reported via {@link + * UserPropagator#onKnownValue}. */ boolean propagateNextDecision(BooleanFormula expr, Optional value); diff --git a/src/org/sosy_lab/java_smt/api/UserPropagator.java b/src/org/sosy_lab/java_smt/api/UserPropagator.java index 9765658d7d..eb7f71e54e 100644 --- a/src/org/sosy_lab/java_smt/api/UserPropagator.java +++ b/src/org/sosy_lab/java_smt/api/UserPropagator.java @@ -65,7 +65,7 @@ public interface UserPropagator { *

Note: This callback is only invoked if the user propagator enabled it via {@link * PropagatorBackend#notifyOnKnownValue()}. * - * @param expr The expressions whose value is known. + * @param expr The expressions whose value is known. * @param value The value of the expression. */ void onKnownValue(BooleanFormula expr, boolean value); @@ -78,7 +78,7 @@ public interface UserPropagator { *

Note: This callback is only invoked if the user propagator enabled it via {@link * PropagatorBackend#notifyOnDecision()}. * - * @param expr The expressions whose value gets decided (usually a literal). + * @param expr The expressions whose value gets decided (usually a literal). * @param value The decision value. */ void onDecision(BooleanFormula expr, boolean value); diff --git a/src/org/sosy_lab/java_smt/basicimpl/AbstractUserPropagator.java b/src/org/sosy_lab/java_smt/basicimpl/AbstractUserPropagator.java index 84afa318f7..5a6941a2cd 100644 --- a/src/org/sosy_lab/java_smt/basicimpl/AbstractUserPropagator.java +++ b/src/org/sosy_lab/java_smt/basicimpl/AbstractUserPropagator.java @@ -24,19 +24,24 @@ protected PropagatorBackend getBackend() { } @Override - public void onPush() {} + public void onPush() { + } @Override - public void onPop(int numPoppedLevels) {} + public void onPop(int numPoppedLevels) { + } @Override - public void onFinalCheck() {} + public void onFinalCheck() { + } @Override - public void onKnownValue(BooleanFormula expr, boolean value) {} + public void onKnownValue(BooleanFormula expr, boolean value) { + } @Override - public void onDecision(BooleanFormula expr, boolean value) {} + public void onDecision(BooleanFormula expr, boolean value) { + } @Override public void initializeWithBackend(PropagatorBackend pBackend) { diff --git a/src/org/sosy_lab/java_smt/example/SimpleUserPropagator.java b/src/org/sosy_lab/java_smt/example/SimpleUserPropagator.java index 213f442065..bbd17b7cdc 100644 --- a/src/org/sosy_lab/java_smt/example/SimpleUserPropagator.java +++ b/src/org/sosy_lab/java_smt/example/SimpleUserPropagator.java @@ -29,10 +29,13 @@ import org.sosy_lab.java_smt.api.SolverException; import org.sosy_lab.java_smt.basicimpl.AbstractUserPropagator; -/** Example of a simple user propagator that prohibits variables/expressions to be set to true. */ +/** + * Example of a simple user propagator that prohibits variables/expressions to be set to true. + */ public class SimpleUserPropagator { - private SimpleUserPropagator() {} + private SimpleUserPropagator() { + } public static void main(String[] args) throws InvalidConfigurationException, InterruptedException, SolverException { @@ -41,7 +44,7 @@ public static void main(String[] args) ShutdownNotifier notifier = ShutdownNotifier.createDummy(); try (SolverContext context = - SolverContextFactory.createSolverContext(config, logger, notifier, Solvers.Z3)) { + SolverContextFactory.createSolverContext(config, logger, notifier, Solvers.Z3)) { final BooleanFormulaManager bmgr = context.getFormulaManager().getBooleanFormulaManager(); testWithBlockedLiterals(context, bmgr, logger); @@ -153,7 +156,9 @@ private static void testWithBlockedSubclauses( } } - /** This user propagator will raise a conflict whenever a registered expression is set to true. */ + /** + * This user propagator will raise a conflict whenever a registered expression is set to true. + */ private static class MyUserPropagator extends AbstractUserPropagator { private final List disabledExpressions = new ArrayList<>(); @@ -178,7 +183,7 @@ public void onKnownValue(BooleanFormula expr, boolean value) { logger.log(Level.INFO, "Solver assigned", expr, "to", value); if (value && disabledExpressions.contains(expr)) { logger.log(Level.INFO, "User propagator raised conflict on", expr); - getBackend().propagateConflict(new BooleanFormula[] {expr}); + getBackend().propagateConflict(new BooleanFormula[]{expr}); } } diff --git a/src/org/sosy_lab/java_smt/example/nqueens_user_propagator/NQueens.java b/src/org/sosy_lab/java_smt/example/nqueens_user_propagator/NQueens.java index 93e5d0ed8c..4f2fc21f18 100644 --- a/src/org/sosy_lab/java_smt/example/nqueens_user_propagator/NQueens.java +++ b/src/org/sosy_lab/java_smt/example/nqueens_user_propagator/NQueens.java @@ -89,10 +89,10 @@ public static void main(String... args) // this example uses Z3, because it is currently the only solver providing user propagation. try (SolverContext context = - SolverContextFactory.createSolverContext(config, logger, notifier, Solvers.Z3); - ProverEnvironment prover = - context.newProverEnvironment( - ProverOptions.GENERATE_MODELS, ProverOptions.GENERATE_ALL_SAT)) { + SolverContextFactory.createSolverContext(config, logger, notifier, Solvers.Z3); + ProverEnvironment prover = + context.newProverEnvironment( + ProverOptions.GENERATE_MODELS, ProverOptions.GENERATE_ALL_SAT)) { // parse input parameters if (args == null || args.length != 2) { @@ -150,7 +150,7 @@ public static void main(String... args) * of size N x N. * * @return a 2D array of BooleanFormula objects, where each BooleanFormula object represents a - * variable for a cell in the grid. + * variable for a cell in the grid. */ private BooleanFormula[][] getSymbols() { final BooleanFormula[][] symbols = new BooleanFormula[n][n]; @@ -167,7 +167,7 @@ private BooleanFormula[][] getSymbols() { * board. * * @param symbols a 2D Boolean array representing the board. Each element is true if there is a - * queen in that cell, false otherwise. + * queen in that cell, false otherwise. * @return a List of BooleanFormulas representing the rules for this constraint. */ private List rowRule1(BooleanFormula[][] symbols) { @@ -196,7 +196,7 @@ private List rowRule1(BooleanFormula[][] symbols) { *

We add a negation of the conjunction of all possible pairs of variables in each row. * * @param symbols a 2D array of BooleanFormula objects representing the variables for each cell on - * the board. + * the board. * @return a list of BooleanFormula objects representing the constraints added by this rule. */ private List rowRule2(BooleanFormula[][] symbols) { @@ -225,7 +225,7 @@ private List rowRule2(BooleanFormula[][] symbols) { *

We add a negation of the conjunction of all possible pairs of variables in each column. * * @param symbols a 2D array of BooleanFormula representing the placement of queens on the - * chessboard + * chessboard * @return a list of BooleanFormula objects representing the constraints added by this rule. */ private List columnRule(BooleanFormula[][] symbols) { @@ -267,7 +267,7 @@ private List columnRule(BooleanFormula[][] symbols) { * * * @param symbols a two-dimensional array of Boolean formulas representing the chessboard - * configuration + * configuration * @return a list of BooleanFormula objects representing the constraints added by this rule. */ private List diagonalRule(BooleanFormula[][] symbols) { diff --git a/src/org/sosy_lab/java_smt/example/nqueens_user_propagator/NQueensConstraintPropagator.java b/src/org/sosy_lab/java_smt/example/nqueens_user_propagator/NQueensConstraintPropagator.java index 329cdd9a17..2fc238aa7c 100644 --- a/src/org/sosy_lab/java_smt/example/nqueens_user_propagator/NQueensConstraintPropagator.java +++ b/src/org/sosy_lab/java_smt/example/nqueens_user_propagator/NQueensConstraintPropagator.java @@ -61,7 +61,7 @@ public void onKnownValue(BooleanFormula var, boolean value) { if (x1 == x2 || y1 == y2 || Math.abs(x1 - x2) == Math.abs(y1 - y2)) { // We have two queens on the same row, same column, or same diagonal. // This is not allowed, so we raise a conflict. - getBackend().propagateConflict(new BooleanFormula[] {var, other}); + getBackend().propagateConflict(new BooleanFormula[]{var, other}); } } } diff --git a/src/org/sosy_lab/java_smt/example/nqueens_user_propagator/package-info.java b/src/org/sosy_lab/java_smt/example/nqueens_user_propagator/package-info.java index e251ddf3a4..44a6aa4093 100644 --- a/src/org/sosy_lab/java_smt/example/nqueens_user_propagator/package-info.java +++ b/src/org/sosy_lab/java_smt/example/nqueens_user_propagator/package-info.java @@ -6,5 +6,7 @@ // // SPDX-License-Identifier: Unlicense OR Apache-2.0 OR MIT -/** Some basic examples for using Java-SMT. */ +/** + * Some basic examples for using Java-SMT. + */ package org.sosy_lab.java_smt.example.nqueens_user_propagator; diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaArrayFormulaManager.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaArrayFormulaManager.java new file mode 100644 index 0000000000..4e853ba93f --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaArrayFormulaManager.java @@ -0,0 +1,52 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_EQUAL; + +import org.sosy_lab.java_smt.api.Formula; +import org.sosy_lab.java_smt.api.FormulaType; +import org.sosy_lab.java_smt.api.FormulaType.ArrayFormulaType; +import org.sosy_lab.java_smt.basicimpl.AbstractArrayFormulaManager; + +public class BitwuzlaArrayFormulaManager + extends AbstractArrayFormulaManager { + + protected BitwuzlaArrayFormulaManager(BitwuzlaFormulaCreator pCreator) { + super(pCreator); + } + + @Override + protected Long select(Long pArray, Long pIndex) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_ARRAY_SELECT.swigValue(), pArray, pIndex); + } + + @Override + protected Long store(Long pArray, Long pIndex, Long pValue) { + return BitwuzlaJNI.bitwuzla_mk_term3( + BitwuzlaKind.BITWUZLA_KIND_ARRAY_STORE.swigValue(), pArray, pIndex, pValue); + } + + @Override + @SuppressWarnings("MethodTypeParameterName") + protected Long internalMakeArray( + String pName, FormulaType pIndexType, FormulaType pElementType) { + final ArrayFormulaType arrayFormulaType = + FormulaType.getArrayType(pIndexType, pElementType); + final long bitwuzlaArrayType = toSolverType(arrayFormulaType); + long newVar = getFormulaCreator().makeVariable(bitwuzlaArrayType, pName); + return newVar; + } + + @Override + protected Long equivalence(Long pArray1, Long pArray2) { + return BitwuzlaJNI.bitwuzla_mk_term2(BITWUZLA_KIND_EQUAL.swigValue(), pArray1, pArray2); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaBitvectorFormulaManager.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaBitvectorFormulaManager.java new file mode 100644 index 0000000000..307157b2cb --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaBitvectorFormulaManager.java @@ -0,0 +1,207 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import java.math.BigInteger; +import org.sosy_lab.java_smt.basicimpl.AbstractBitvectorFormulaManager; +import org.sosy_lab.java_smt.basicimpl.AbstractBooleanFormulaManager; +import org.sosy_lab.java_smt.basicimpl.FormulaCreator; + +public class BitwuzlaBitvectorFormulaManager + extends AbstractBitvectorFormulaManager { + + protected BitwuzlaBitvectorFormulaManager( + FormulaCreator pCreator, + AbstractBooleanFormulaManager pBmgr) { + super(pCreator, pBmgr); + } + + @Override + protected Long makeBitvectorImpl(int length, Long pParam1) { + throw new UnsupportedOperationException("Bitwuzla does not support INT theory"); + } + + @Override + protected Long makeBitvectorImpl(int length, BigInteger pI) { + pI = transformValueToRange(length, pI); + long sort = BitwuzlaJNI.bitwuzla_mk_bv_sort(length); + return BitwuzlaJNI.bitwuzla_mk_bv_value(sort, pI.toString(), 10); + } + + @Override + protected Long toIntegerFormulaImpl(Long pI, boolean signed) { + throw new UnsupportedOperationException("BV to INT conversion is not supported."); + } + + @Override + protected Long negate(Long pParam1) { + return BitwuzlaJNI.bitwuzla_mk_term1(BitwuzlaKind.BITWUZLA_KIND_BV_NOT.swigValue(), pParam1); + } + + @Override + protected Long add(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_ADD.swigValue(), pParam1, pParam2); + } + + @Override + protected Long subtract(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_SUB.swigValue(), pParam1, pParam2); + } + + @Override + protected Long divide(Long pParam1, Long pParam2, boolean signed) { + if (signed) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_SDIV.swigValue(), pParam1, pParam2); + } else { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_UDIV.swigValue(), pParam1, pParam2); + } + } + + @Override + protected Long remainder(Long pParam1, Long pParam2, boolean signed) { + BitwuzlaKind kind = + signed ? BitwuzlaKind.BITWUZLA_KIND_BV_SREM : BitwuzlaKind.BITWUZLA_KIND_BV_UREM; + return BitwuzlaJNI.bitwuzla_mk_term2(kind.swigValue(), pParam1, pParam2); + } + + @Override + protected Long smodulo(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_SMOD.swigValue(), pParam1, pParam2); + } + + @Override + protected Long multiply(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_MUL.swigValue(), pParam1, pParam2); + } + + @Override + protected Long equal(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), pParam1, pParam2); + } + + @Override + protected Long greaterThan(Long pParam1, Long pParam2, boolean signed) { + if (signed) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_SGT.swigValue(), pParam1, pParam2); + } else { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_UGT.swigValue(), pParam1, pParam2); + } + } + + @Override + protected Long greaterOrEquals(Long pParam1, Long pParam2, boolean signed) { + if (signed) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_SGE.swigValue(), pParam1, pParam2); + } else { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_UGE.swigValue(), pParam1, pParam2); + } + } + + @Override + protected Long lessThan(Long pParam1, Long pParam2, boolean signed) { + if (signed) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_SLT.swigValue(), pParam1, pParam2); + } else { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_ULT.swigValue(), pParam1, pParam2); + } + } + + @Override + protected Long lessOrEquals(Long pParam1, Long pParam2, boolean signed) { + if (signed) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_SLE.swigValue(), pParam1, pParam2); + } else { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_ULE.swigValue(), pParam1, pParam2); + } + } + + @Override + protected Long not(Long pParam1) { + return BitwuzlaJNI.bitwuzla_mk_term1(BitwuzlaKind.BITWUZLA_KIND_BV_NOT.swigValue(), pParam1); + } + + @Override + protected Long and(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_AND.swigValue(), pParam1, pParam2); + } + + @Override + protected Long or(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_OR.swigValue(), pParam1, pParam2); + } + + @Override + protected Long xor(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_XOR.swigValue(), pParam1, pParam2); + } + + @Override + protected Long makeVariableImpl(int pLength, String pVar) { + long sort = BitwuzlaJNI.bitwuzla_mk_bv_sort(pLength); + return getFormulaCreator().makeVariable(sort, pVar); + } + + @Override + protected Long shiftRight(Long pNumber, Long toShift, boolean signed) { + if (signed) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_ASHR.swigValue(), pNumber, toShift); + } else { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_SHR.swigValue(), pNumber, toShift); + } + } + + @Override + protected Long shiftLeft(Long pNumber, Long toShift) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_SHL.swigValue(), pNumber, toShift); + } + + @Override + protected Long concat(Long number, Long pAppend) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_CONCAT.swigValue(), number, pAppend); + } + + @Override + protected Long extract(Long pNumber, int pMsb, int pLsb) { + return BitwuzlaJNI.bitwuzla_mk_term1_indexed2( + BitwuzlaKind.BITWUZLA_KIND_BV_EXTRACT.swigValue(), pNumber, pMsb, pLsb); + } + + @Override + protected Long extend(Long pNumber, int pExtensionBits, boolean pSigned) { + if (pSigned) { + return BitwuzlaJNI.bitwuzla_mk_term1_indexed1( + BitwuzlaKind.BITWUZLA_KIND_BV_SIGN_EXTEND.swigValue(), pNumber, pExtensionBits); + } else { + return BitwuzlaJNI.bitwuzla_mk_term1_indexed1( + BitwuzlaKind.BITWUZLA_KIND_BV_ZERO_EXTEND.swigValue(), pNumber, pExtensionBits); + } + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaBooleanFormulaManager.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaBooleanFormulaManager.java new file mode 100644 index 0000000000..cdaa9c96bd --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaBooleanFormulaManager.java @@ -0,0 +1,126 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import org.sosy_lab.java_smt.basicimpl.AbstractBooleanFormulaManager; +import org.sosy_lab.java_smt.basicimpl.FormulaCreator; + +public class BitwuzlaBooleanFormulaManager + extends AbstractBooleanFormulaManager { + // private final long bitwuzla; + private final long pTrue; + private final long pFalse; + + protected BitwuzlaBooleanFormulaManager( + FormulaCreator pCreator) { + super(pCreator); + // bitwuzla = getFormulaCreator().getEnv(); + pTrue = BitwuzlaJNI.bitwuzla_mk_true(); + pFalse = BitwuzlaJNI.bitwuzla_mk_false(); + } + + @Override + protected Long makeVariableImpl(String pVar) { + long boolType = getFormulaCreator().getBoolType(); + return getFormulaCreator().makeVariable(boolType, pVar); + } + + @Override + protected Long makeBooleanImpl(boolean value) { + return value ? pTrue : pFalse; + } + + @Override + protected Long not(Long pParam1) { + if (isTrue(pParam1)) { + return pFalse; + } else if (isFalse(pParam1)) { + return pTrue; + } + + if (BitwuzlaJNI.bitwuzla_term_get_kind(pParam1) == BitwuzlaKind.BITWUZLA_KIND_NOT.swigValue()) { + long[] size = new long[1]; + long[] pChildren = BitwuzlaJNI.bitwuzla_term_get_children(pParam1, size); + return pChildren[0]; + } + return BitwuzlaJNI.bitwuzla_mk_term1(BitwuzlaKind.BITWUZLA_KIND_NOT.swigValue(), pParam1); + } + + @Override + protected Long and(Long pParam1, Long pParam2) { + if (isTrue(pParam1)) { + return pParam2; + } else if (isTrue(pParam2)) { + return pParam1; + } else if (isFalse(pParam1)) { + return pFalse; + } else if (isFalse(pParam2)) { + return pFalse; + } else if (pParam1.equals(pParam2)) { + return pParam1; + } + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_AND.swigValue(), pParam1, pParam2); + } + + @Override + protected Long or(Long pParam1, Long pParam2) { + if (isTrue(pParam1)) { + return pTrue; + } else if (isTrue(pParam2)) { + return pTrue; + } else if (isFalse(pParam1)) { + return pParam2; + } else if (isFalse(pParam2)) { + return pParam1; + } else if (pParam1.equals(pParam2)) { + return pParam1; + } + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_OR.swigValue(), pParam1, pParam2); + } + + @Override + protected Long xor(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_XOR.swigValue(), pParam1, pParam2); + } + + @Override + protected Long equivalence(Long bits1, Long bits2) { + return BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_IFF.swigValue(), bits1, bits2); + } + + @Override + protected boolean isTrue(Long bits) { + return BitwuzlaJNI.bitwuzla_term_is_true(bits); + } + + @Override + protected boolean isFalse(Long bits) { + return BitwuzlaJNI.bitwuzla_term_is_false(bits); + } + + @Override + protected Long ifThenElse(Long pCond, Long pF1, Long pF2) { + if (isTrue(pCond)) { + return pF1; + } else if (isFalse(pCond)) { + return pF2; + } else if (pF1.equals(pF2)) { + return pF1; + } else if (isTrue(pF1) && isFalse(pF2)) { + return pCond; + } else if (isFalse(pF1) && isTrue(pF2)) { + return not(pCond); + } + return BitwuzlaJNI.bitwuzla_mk_term3( + BitwuzlaKind.BITWUZLA_KIND_ITE.swigValue(), pCond, pF1, pF2); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaDeclaration.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaDeclaration.java new file mode 100644 index 0000000000..c93da123ac --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaDeclaration.java @@ -0,0 +1,59 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import java.util.Objects; + +// Declarations sometimes need the info of a Term, but mostly those of Kinds. +// We can not discern between the two however, hence this wrapper +public class BitwuzlaDeclaration { + private final Long decl; + + // If isKind, decl == KIND; else decl == term + private final boolean isKind; + + BitwuzlaDeclaration(long pDecl, boolean pIsKind) { + decl = pDecl; + isKind = pIsKind; + } + + public boolean isKind() { + return isKind; + } + + public long getTerm() { + assert !isKind; + return decl; + } + + public int getKind() { + assert isKind; + return decl.intValue(); + } + + @Override + public boolean equals(Object any) { + if (any == this) { + return true; + } + if (any instanceof BitwuzlaDeclaration) { + BitwuzlaDeclaration otherDecl = (BitwuzlaDeclaration) any; + if (this.isKind == otherDecl.isKind && Objects.equals(this.decl, otherDecl.decl)) { + return true; + } + } + return false; + } + + @Override + public int hashCode() { + // Might be errorprone as term and kind might have the same hashcode but not be equal + return decl != null ? decl.hashCode() : 0; + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaFloatingPointManager.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaFloatingPointManager.java new file mode 100644 index 0000000000..7e0a2a92c1 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaFloatingPointManager.java @@ -0,0 +1,339 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_EQUAL; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_ABS; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_ADD; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_DIV; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_EQUAL; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_GEQ; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_GT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_IS_INF; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_IS_NAN; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_IS_NEG; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_IS_NORMAL; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_IS_SUBNORMAL; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_IS_ZERO; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_LEQ; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_LT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_MAX; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_MIN; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_MUL; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_NEG; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_RTI; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_SQRT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_SUB; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_TO_FP_FROM_BV; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_TO_FP_FROM_FP; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_TO_FP_FROM_SBV; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_TO_FP_FROM_UBV; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_TO_SBV; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_TO_UBV; + +import java.math.BigInteger; +import org.sosy_lab.java_smt.api.FloatingPointRoundingMode; +import org.sosy_lab.java_smt.api.FormulaType; +import org.sosy_lab.java_smt.api.FormulaType.FloatingPointType; +import org.sosy_lab.java_smt.basicimpl.AbstractFloatingPointFormulaManager; +import org.sosy_lab.java_smt.basicimpl.FormulaCreator; + +public class BitwuzlaFloatingPointManager + extends AbstractFloatingPointFormulaManager { + // private final long bitwuzla; + private final long roundingMode; + + protected BitwuzlaFloatingPointManager( + FormulaCreator pCreator, + FloatingPointRoundingMode pFloatingPointRoundingMode) { + super(pCreator); + // bitwuzla = pCreator.getEnv(); + roundingMode = getRoundingModeImpl(pFloatingPointRoundingMode); + } + + @Override + protected Long getDefaultRoundingMode() { + return roundingMode; + } + + @Override + protected Long getRoundingModeImpl(FloatingPointRoundingMode pFloatingPointRoundingMode) { + long out; + switch (pFloatingPointRoundingMode) { + case NEAREST_TIES_TO_EVEN: + out = BitwuzlaJNI.bitwuzla_mk_rm_value(BitwuzlaJNI.BITWUZLA_RM_RNE_get()); + break; + case NEAREST_TIES_AWAY: + out = BitwuzlaJNI.bitwuzla_mk_rm_value(BitwuzlaJNI.BITWUZLA_RM_RNA_get()); + break; + case TOWARD_POSITIVE: + out = BitwuzlaJNI.bitwuzla_mk_rm_value(BitwuzlaJNI.BITWUZLA_RM_RTP_get()); + break; + case TOWARD_NEGATIVE: + out = BitwuzlaJNI.bitwuzla_mk_rm_value(BitwuzlaJNI.BITWUZLA_RM_RTN_get()); + break; + case TOWARD_ZERO: + out = BitwuzlaJNI.bitwuzla_mk_rm_value(BitwuzlaJNI.BITWUZLA_RM_RTZ_get()); + break; + default: + throw new AssertionError("Unexpected value"); + } + return out; + } + + @Override + protected Long makeNumberImpl(double n, FloatingPointType type, Long pFloatingPointRoundingMode) { + if (Double.compare(n, -0.0) == 0) { + return BitwuzlaJNI.bitwuzla_mk_fp_neg_zero(mkFpaSort(type)); + } else { + return makeNumberImpl(String.format("%f", n), type, pFloatingPointRoundingMode); + } + } + + @Override + protected Long makeNumberImpl( + BigInteger exponent, + BigInteger mantissa, + boolean signBit, + FloatingPointType type) { + // FIXME: Implement by converting the arguments to bitvectors? + throw new UnsupportedOperationException(); + } + + private long mkFpaSort(FloatingPointType pType) { + return getFormulaCreator().getFloatingPointType(pType); + } + + @Override + protected Long makeNumberAndRound( + String pN, FloatingPointType pType, Long pFloatingPointRoundingMode) { + // Convert scientific notation (f.ex "1.234E2") to a plain decimal string (f.ex "123.4") + String decimals = String.format("%.0f", Double.parseDouble(pN)); + if (Double.compare(Double.parseDouble(pN), -0.0) == 0) { + return BitwuzlaJNI.bitwuzla_mk_fp_neg_zero(mkFpaSort(pType)); + } else { + return BitwuzlaJNI.bitwuzla_mk_fp_from_real( + mkFpaSort(pType), pFloatingPointRoundingMode, decimals); + } + } + + @Override + protected Long makeVariableImpl(String pVar, FloatingPointType pType) { + return getFormulaCreator().makeVariable(mkFpaSort(pType), pVar); + } + + @Override + protected Long makePlusInfinityImpl(FloatingPointType pType) { + return BitwuzlaJNI.bitwuzla_mk_fp_pos_inf(mkFpaSort(pType)); + } + + @Override + protected Long makeMinusInfinityImpl(FloatingPointType pType) { + return BitwuzlaJNI.bitwuzla_mk_fp_neg_inf(mkFpaSort(pType)); + } + + @Override + protected Long makeNaNImpl(FloatingPointType pType) { + return BitwuzlaJNI.bitwuzla_mk_fp_nan(mkFpaSort(pType)); + } + + @Override + protected Long castToImpl( + Long pNumber, boolean pSigned, FormulaType pTargetType, Long pRoundingMode) { + if (pTargetType.isFloatingPointType()) { + FormulaType.FloatingPointType targetType = (FormulaType.FloatingPointType) pTargetType; + return BitwuzlaJNI.bitwuzla_mk_term2_indexed2( + BITWUZLA_KIND_FP_TO_FP_FROM_FP.swigValue(), + pRoundingMode, + pNumber, + targetType.getExponentSize(), + targetType.getMantissaSize() + 1); + } else if (pTargetType.isBitvectorType()) { + FormulaType.BitvectorType targetType = (FormulaType.BitvectorType) pTargetType; + if (pSigned) { + return BitwuzlaJNI.bitwuzla_mk_term2_indexed1( + BITWUZLA_KIND_FP_TO_SBV.swigValue(), pRoundingMode, pNumber, targetType.getSize()); + } else { + return BitwuzlaJNI.bitwuzla_mk_term2_indexed1( + BITWUZLA_KIND_FP_TO_UBV.swigValue(), pRoundingMode, pNumber, targetType.getSize()); + } + } else { + throw new UnsupportedOperationException("Attempted cast to an unsupported type."); + } + } + + @Override + protected Long castFromImpl( + Long pNumber, boolean pSigned, FloatingPointType pTargetType, Long pRoundingMode) { + FormulaType formulaType = getFormulaCreator().getFormulaType(pNumber); + if (formulaType.isFloatingPointType()) { + return castToImpl(pNumber, pSigned, pTargetType, pRoundingMode); + } else if (formulaType.isBitvectorType()) { + if (pSigned) { + return BitwuzlaJNI.bitwuzla_mk_term2_indexed2( + BITWUZLA_KIND_FP_TO_FP_FROM_SBV.swigValue(), + roundingMode, + pNumber, + pTargetType.getExponentSize(), + pTargetType.getMantissaSize() + 1); + } else { + return BitwuzlaJNI.bitwuzla_mk_term2_indexed2( + BITWUZLA_KIND_FP_TO_FP_FROM_UBV.swigValue(), + roundingMode, + pNumber, + pTargetType.getExponentSize(), + pTargetType.getMantissaSize() + 1); + } + + } else { + throw new UnsupportedOperationException("Attempted cast from an unsupported type."); + } + } + + @Override + protected Long fromIeeeBitvectorImpl(Long pNumber, FloatingPointType pTargetType) { + return BitwuzlaJNI.bitwuzla_mk_term1_indexed2( + BITWUZLA_KIND_FP_TO_FP_FROM_BV.swigValue(), + pNumber, + pTargetType.getExponentSize(), + pTargetType.getMantissaSize() + 1); + } + + @Override + protected Long toIeeeBitvectorImpl(Long pNumber) { + long rm = BitwuzlaJNI.bitwuzla_mk_rm_value(BitwuzlaJNI.BITWUZLA_RM_RTZ_get()); + long inputBits = + BitwuzlaJNI.bitwuzla_term_fp_get_exp_size(pNumber) + + BitwuzlaJNI.bitwuzla_term_fp_get_sig_size(pNumber); + // This is most likely wrong/inprecise! + return BitwuzlaJNI.bitwuzla_mk_term2_indexed1( + BITWUZLA_KIND_FP_TO_SBV.swigValue(), rm, pNumber, inputBits); + } + + @Override + protected Long negate(Long pParam1) { + return BitwuzlaJNI.bitwuzla_mk_term1(BITWUZLA_KIND_FP_NEG.swigValue(), pParam1); + } + + @Override + protected Long abs(Long pParam1) { + return BitwuzlaJNI.bitwuzla_mk_term1(BITWUZLA_KIND_FP_ABS.swigValue(), pParam1); + } + + @Override + protected Long max(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2(BITWUZLA_KIND_FP_MAX.swigValue(), pParam1, pParam2); + } + + @Override + protected Long min(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2(BITWUZLA_KIND_FP_MIN.swigValue(), pParam1, pParam2); + } + + @Override + protected Long sqrt(Long pNumber, Long pRoundingMode) { + return BitwuzlaJNI.bitwuzla_mk_term2(BITWUZLA_KIND_FP_SQRT.swigValue(), pRoundingMode, pNumber); + } + + @Override + protected Long add(Long pParam1, Long pParam2, Long pRoundingMode) { + return BitwuzlaJNI.bitwuzla_mk_term3( + BITWUZLA_KIND_FP_ADD.swigValue(), pRoundingMode, pParam1, pParam2); + } + + @Override + protected Long subtract(Long pParam1, Long pParam2, Long pFloatingPointRoundingMode) { + return BitwuzlaJNI.bitwuzla_mk_term3( + BITWUZLA_KIND_FP_SUB.swigValue(), pFloatingPointRoundingMode, pParam1, pParam2); + } + + @Override + protected Long divide(Long pParam1, Long pParam2, Long pFloatingPointRoundingMode) { + return BitwuzlaJNI.bitwuzla_mk_term3( + BITWUZLA_KIND_FP_DIV.swigValue(), pFloatingPointRoundingMode, pParam1, pParam2); + } + + @Override + protected Long multiply(Long pParam1, Long pParam2, Long pFloatingPointRoundingMode) { + return BitwuzlaJNI.bitwuzla_mk_term3( + BITWUZLA_KIND_FP_MUL.swigValue(), pFloatingPointRoundingMode, pParam1, pParam2); + } + + @Override + protected Long remainder(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_FP_REM.swigValue(), pParam1, pParam2); + } + + @Override + protected Long assignment(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2(BITWUZLA_KIND_EQUAL.swigValue(), pParam1, pParam2); + } + + @Override + protected Long equalWithFPSemantics(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2(BITWUZLA_KIND_FP_EQUAL.swigValue(), pParam1, pParam2); + } + + @Override + protected Long greaterThan(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2(BITWUZLA_KIND_FP_GT.swigValue(), pParam1, pParam2); + } + + @Override + protected Long greaterOrEquals(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2(BITWUZLA_KIND_FP_GEQ.swigValue(), pParam1, pParam2); + } + + @Override + protected Long lessThan(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2(BITWUZLA_KIND_FP_LT.swigValue(), pParam1, pParam2); + } + + @Override + protected Long lessOrEquals(Long pParam1, Long pParam2) { + return BitwuzlaJNI.bitwuzla_mk_term2(BITWUZLA_KIND_FP_LEQ.swigValue(), pParam1, pParam2); + } + + @Override + protected Long isNaN(Long pParam) { + return BitwuzlaJNI.bitwuzla_mk_term1(BITWUZLA_KIND_FP_IS_NAN.swigValue(), pParam); + } + + @Override + protected Long isInfinity(Long pParam) { + return BitwuzlaJNI.bitwuzla_mk_term1(BITWUZLA_KIND_FP_IS_INF.swigValue(), pParam); + } + + @Override + protected Long isZero(Long pParam) { + return BitwuzlaJNI.bitwuzla_mk_term1(BITWUZLA_KIND_FP_IS_ZERO.swigValue(), pParam); + } + + @Override + protected Long isSubnormal(Long pParam) { + return BitwuzlaJNI.bitwuzla_mk_term1(BITWUZLA_KIND_FP_IS_SUBNORMAL.swigValue(), pParam); + } + + @Override + protected Long isNormal(Long pParam) { + return BitwuzlaJNI.bitwuzla_mk_term1(BITWUZLA_KIND_FP_IS_NORMAL.swigValue(), pParam); + } + + @Override + protected Long isNegative(Long pParam) { + return BitwuzlaJNI.bitwuzla_mk_term1(BITWUZLA_KIND_FP_IS_NEG.swigValue(), pParam); + } + + @Override + protected Long round(Long pFormula, FloatingPointRoundingMode pRoundingMode) { + long rm = getRoundingModeImpl(pRoundingMode); + return BitwuzlaJNI.bitwuzla_mk_term2(BITWUZLA_KIND_FP_RTI.swigValue(), rm, pFormula); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaFormula.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaFormula.java new file mode 100644 index 0000000000..d47f7a05d6 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaFormula.java @@ -0,0 +1,123 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import com.google.errorprone.annotations.Immutable; +import org.sosy_lab.java_smt.api.ArrayFormula; +import org.sosy_lab.java_smt.api.BitvectorFormula; +import org.sosy_lab.java_smt.api.BooleanFormula; +import org.sosy_lab.java_smt.api.FloatingPointFormula; +import org.sosy_lab.java_smt.api.FloatingPointRoundingModeFormula; +import org.sosy_lab.java_smt.api.Formula; +import org.sosy_lab.java_smt.api.FormulaType; +import org.sosy_lab.java_smt.api.visitors.FormulaVisitor; + +@Immutable +abstract class BitwuzlaFormula implements Formula { + private final long bitwuzlaTerm; + + BitwuzlaFormula(long term) { + bitwuzlaTerm = term; + } + + final long getTerm() { + return bitwuzlaTerm; + } + + /** + * returns an arbitrary representation of the formula, might be human- or machine-readable. + * + *

We do not guarantee that the returned String is in any way related to the formula. The + * solver might apply escaping or even un-escaping. A user should not use the returned String for + * further processing. For analyzing formulas, we recommend using a {@link FormulaVisitor}. + */ + @Override + public String toString() { + return BitwuzlaJNI.bitwuzla_term_to_string(this.bitwuzlaTerm); + } + + /** + * checks whether the other object is a formula of the same structure. Does not apply an expensive + * SAT-check to check equisatisfiability. + * + *

Two formulas that are structured in the same way, are determined as "equal". Due to + * transformations and simplifications, two equisatisfiable formulas with different structure + * might not be determined as "equal". + */ + @Override + public boolean equals(Object other) { + if (other == this) { + return true; + } + if (!(other instanceof BitwuzlaFormula)) { + return false; + } + return bitwuzlaTerm == ((BitwuzlaFormula) other).getTerm(); + } + + /** returns a valid hashCode satisfying the constraints given by {@link #equals}. */ + @Override + public int hashCode() { + // In this case, the long returned by the JNI is not a pointer, but the value itself. + return (int) BitwuzlaJNI.bitwuzla_term_hash(bitwuzlaTerm); + } + + @Immutable + @SuppressWarnings("ClassTypeParameterName") + static final class BitwuzlaArrayFormula + extends BitwuzlaFormula implements ArrayFormula { + + private final FormulaType indexType; + private final FormulaType elementType; + + BitwuzlaArrayFormula(long pTerm, FormulaType pIndexType, FormulaType pElementType) { + super(pTerm); + indexType = pIndexType; + elementType = pElementType; + } + + public FormulaType getIndexType() { + return indexType; + } + + public FormulaType getElementType() { + return elementType; + } + } + + @Immutable + static final class BitwuzlaBitvectorFormula extends BitwuzlaFormula implements BitvectorFormula { + BitwuzlaBitvectorFormula(long pTerm) { + super(pTerm); + } + } + + @Immutable + static final class BitwuzlaFloatingPointFormula extends BitwuzlaFormula + implements FloatingPointFormula { + BitwuzlaFloatingPointFormula(long pTerm) { + super(pTerm); + } + } + + @Immutable + static final class BitwuzlaFloatingPointRoundingModeFormula extends BitwuzlaFormula + implements FloatingPointRoundingModeFormula { + BitwuzlaFloatingPointRoundingModeFormula(long pTerm) { + super(pTerm); + } + } + + @Immutable + static final class BitwuzlaBooleanFormula extends BitwuzlaFormula implements BooleanFormula { + BitwuzlaBooleanFormula(long pTerm) { + super(pTerm); + } + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaFormulaCreator.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaFormulaCreator.java new file mode 100644 index 0000000000..02cf419bdb --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaFormulaCreator.java @@ -0,0 +1,695 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import static com.google.common.base.Preconditions.checkArgument; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_AND; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_APPLY; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_ARRAY_SELECT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_ARRAY_STORE; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_ADD; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_AND; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_ASHR; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_CONCAT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_EXTRACT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_MUL; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_NEG; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_NOT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_OR; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_SDIV; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_SGE; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_SGT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_SHL; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_SIGN_EXTEND; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_SLE; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_SLT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_SMOD; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_SREM; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_SUB; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_UDIV; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_UGE; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_UGT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_ULE; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_ULT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_UREM; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_XOR; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_BV_ZERO_EXTEND; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_CONSTANT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_DISTINCT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_EQUAL; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_EXISTS; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FORALL; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_ABS; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_ADD; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_DIV; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_EQUAL; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_GEQ; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_GT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_IS_INF; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_IS_NAN; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_IS_NEG; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_IS_NORMAL; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_IS_SUBNORMAL; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_IS_ZERO; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_LEQ; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_LT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_MAX; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_MIN; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_MUL; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_NEG; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_RTI; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_SQRT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_SUB; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_TO_FP_FROM_BV; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_TO_FP_FROM_FP; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_TO_FP_FROM_SBV; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_TO_FP_FROM_UBV; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_TO_SBV; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_FP_TO_UBV; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_IFF; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_IMPLIES; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_ITE; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_NOT; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_OR; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_VALUE; +import static org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaKind.BITWUZLA_KIND_XOR; + +import com.google.common.collect.HashBasedTable; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Table; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Map.Entry; +import java.util.Optional; +import java.util.stream.LongStream; +import org.sosy_lab.java_smt.api.ArrayFormula; +import org.sosy_lab.java_smt.api.BitvectorFormula; +import org.sosy_lab.java_smt.api.BooleanFormula; +import org.sosy_lab.java_smt.api.FloatingPointFormula; +import org.sosy_lab.java_smt.api.Formula; +import org.sosy_lab.java_smt.api.FormulaType; +import org.sosy_lab.java_smt.api.FormulaType.ArrayFormulaType; +import org.sosy_lab.java_smt.api.FormulaType.FloatingPointType; +import org.sosy_lab.java_smt.api.FunctionDeclarationKind; +import org.sosy_lab.java_smt.api.QuantifiedFormulaManager.Quantifier; +import org.sosy_lab.java_smt.api.visitors.FormulaVisitor; +import org.sosy_lab.java_smt.basicimpl.FormulaCreator; +import org.sosy_lab.java_smt.basicimpl.FunctionDeclarationImpl; +import org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaFormula.BitwuzlaArrayFormula; +import org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaFormula.BitwuzlaBitvectorFormula; +import org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaFormula.BitwuzlaBooleanFormula; +import org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaFormula.BitwuzlaFloatingPointFormula; +import org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaFormula.BitwuzlaFloatingPointRoundingModeFormula; + +public class BitwuzlaFormulaCreator extends FormulaCreator { + private final Table formulaCache = HashBasedTable.create(); + + // private final Table boundFormulaCache = HashBasedTable.create(); + + protected BitwuzlaFormulaCreator(Long pBitwuzlaEnv) { + super(pBitwuzlaEnv, BitwuzlaJNI.bitwuzla_mk_bool_sort(), null, null, null, null); + } + + @Override + public Long getBitvectorType(int bitwidth) { + return BitwuzlaJNI.bitwuzla_mk_bv_sort(bitwidth); + } + + @Override + public BitvectorFormula encapsulateBitvector(Long pTerm) { + assert getFormulaType(pTerm).isBitvectorType() + : "Unexpected formula type for BV formula: " + getFormulaType(pTerm); + return new BitwuzlaBitvectorFormula(pTerm); + } + + // Assuming that JavaSMT FloatingPointType follows IEEE 754, if it is in the decimal + // system instead use bitwuzla_mk_fp_value_from_real somehow or convert myself + @Override + public Long getFloatingPointType(FloatingPointType type) { + long fpSort = + BitwuzlaJNI.bitwuzla_mk_fp_sort(type.getExponentSize(), type.getMantissaSize() + 1); + return fpSort; + } + + @Override + @SuppressWarnings("MethodTypeParameterName") + protected FormulaType getArrayFormulaElementType( + ArrayFormula pArray) { + return ((BitwuzlaArrayFormula) pArray).getElementType(); + } + + @Override + @SuppressWarnings("MethodTypeParameterName") + protected FormulaType getArrayFormulaIndexType( + ArrayFormula pArray) { + return ((BitwuzlaArrayFormula) pArray).getIndexType(); + } + + @Override + public Long getArrayType(Long indexType, Long elementType) { + return BitwuzlaJNI.bitwuzla_mk_array_sort(indexType, elementType); + } + + @Override + protected FloatingPointFormula encapsulateFloatingPoint(Long pTerm) { + assert getFormulaType(pTerm).isFloatingPointType() + : String.format( + "%s is no FP, but %s (%s)", + pTerm, BitwuzlaJNI.bitwuzla_term_get_sort(pTerm), getFormulaType(pTerm)); + return new BitwuzlaFloatingPointFormula(pTerm); + } + + @Override + @SuppressWarnings("MethodTypeParameterName") + protected ArrayFormula encapsulateArray( + Long pTerm, FormulaType pIndexType, FormulaType pElementType) { + assert getFormulaType(pTerm).isArrayType() + : "Unexpected formula type for array formula: " + getFormulaType(pTerm); + return new BitwuzlaArrayFormula<>(pTerm, pIndexType, pElementType); + } + + @Override + public Long makeVariable(Long pSort, String varName) { + Long maybeFormula = formulaCache.get(varName, pSort); + if (maybeFormula != null) { + return maybeFormula; + } + + long newVar = BitwuzlaJNI.bitwuzla_mk_const(pSort, varName); + formulaCache.put(varName, pSort, newVar); + return newVar; + } + + public long makeBoundVariable(long var) { + String name = BitwuzlaJNI.bitwuzla_term_get_symbol(var); + Long sort = BitwuzlaJNI.bitwuzla_term_get_sort(var); + // TODO: do we need a bound cache? + // Long maybeVar = boundFormulaCache.get(name, sort); + // if (maybeVar != null) { + // return maybeVar; + // } + + long newVar = BitwuzlaJNI.bitwuzla_mk_var(sort, name); + // boundFormulaCache.put(name, sort, newVar); + return newVar; + } + + public FormulaType bitwuzlaSortToType(Long pSort) { + // UFs play by different rules. For them, we need to extract the domain + if (BitwuzlaJNI.bitwuzla_sort_is_fp(pSort)) { + long exponent = BitwuzlaJNI.bitwuzla_sort_fp_get_exp_size(pSort); + long mantissa = BitwuzlaJNI.bitwuzla_sort_fp_get_sig_size(pSort) - 1; + return FormulaType.getFloatingPointType((int) exponent, (int) mantissa); + } else if (BitwuzlaJNI.bitwuzla_sort_is_bv(pSort)) { + return FormulaType.getBitvectorTypeWithSize( + (int) BitwuzlaJNI.bitwuzla_sort_bv_get_size(pSort)); + } else if (BitwuzlaJNI.bitwuzla_sort_is_array(pSort)) { + FormulaType domainSort = + bitwuzlaSortToType(BitwuzlaJNI.bitwuzla_sort_array_get_element(pSort)); + FormulaType rangeSort = + bitwuzlaSortToType(BitwuzlaJNI.bitwuzla_sort_array_get_index(pSort)); + return FormulaType.getArrayType(domainSort, rangeSort); + } else if (BitwuzlaJNI.bitwuzla_sort_is_bool(pSort)) { + return FormulaType.BooleanType; + } else if (BitwuzlaJNI.bitwuzla_sort_is_rm(pSort)) { + return FormulaType.FloatingPointRoundingModeType; + } + + throw new UnsupportedOperationException( + "Could not find the JavaSMT type for sort" + + BitwuzlaJNI.bitwuzla_sort_to_string(pSort) + + "."); + } + + private FunctionDeclarationKind getDeclarationKind(Long term) { + BitwuzlaKind kind = BitwuzlaKind.swigToEnum(BitwuzlaJNI.bitwuzla_term_get_kind(term)); + + if (kind.equals(BITWUZLA_KIND_AND)) { + return FunctionDeclarationKind.AND; + } else if (kind.equals(BITWUZLA_KIND_DISTINCT)) { + return FunctionDeclarationKind.DISTINCT; + } else if (kind.equals(BITWUZLA_KIND_EQUAL)) { + return FunctionDeclarationKind.EQ; + } else if (kind.equals(BITWUZLA_KIND_IFF)) { + return FunctionDeclarationKind.IFF; + } else if (kind.equals(BITWUZLA_KIND_IMPLIES)) { + return FunctionDeclarationKind.IMPLIES; + } else if (kind.equals(BITWUZLA_KIND_NOT)) { + return FunctionDeclarationKind.NOT; + } else if (kind.equals(BITWUZLA_KIND_OR)) { + return FunctionDeclarationKind.OR; + } else if (kind.equals(BITWUZLA_KIND_XOR)) { + return FunctionDeclarationKind.XOR; + } else if (kind.equals(BITWUZLA_KIND_ITE)) { + return FunctionDeclarationKind.ITE; + } else if (kind.equals(BITWUZLA_KIND_APPLY)) { + return FunctionDeclarationKind.UF; + } else if (kind.equals(BITWUZLA_KIND_ARRAY_SELECT)) { + return FunctionDeclarationKind.SELECT; + } else if (kind.equals(BITWUZLA_KIND_ARRAY_STORE)) { + return FunctionDeclarationKind.STORE; + } else if (kind.equals(BITWUZLA_KIND_BV_ADD)) { + return FunctionDeclarationKind.BV_ADD; + } else if (kind.equals(BITWUZLA_KIND_BV_AND)) { + return FunctionDeclarationKind.BV_AND; + } else if (kind.equals(BITWUZLA_KIND_BV_ASHR)) { + return FunctionDeclarationKind.BV_ASHR; + } else if (kind.equals(BITWUZLA_KIND_BV_CONCAT)) { + return FunctionDeclarationKind.BV_CONCAT; + } else if (kind.equals(BITWUZLA_KIND_BV_SMOD)) { + return FunctionDeclarationKind.BV_SMOD; + } else if (kind.equals(BITWUZLA_KIND_BV_MUL)) { + return FunctionDeclarationKind.BV_MUL; + } else if (kind.equals(BITWUZLA_KIND_BV_NEG)) { + return FunctionDeclarationKind.BV_NEG; + } else if (kind.equals(BITWUZLA_KIND_BV_NOT)) { + return FunctionDeclarationKind.BV_NOT; + } else if (kind.equals(BITWUZLA_KIND_BV_OR)) { + return FunctionDeclarationKind.BV_OR; + } else if (kind.equals(BITWUZLA_KIND_BV_SDIV)) { + return FunctionDeclarationKind.BV_SDIV; + } else if (kind.equals(BITWUZLA_KIND_BV_SGE)) { + return FunctionDeclarationKind.BV_SGE; + } else if (kind.equals(BITWUZLA_KIND_BV_SGT)) { + return FunctionDeclarationKind.BV_SGT; + } else if (kind.equals(BITWUZLA_KIND_BV_SHL)) { + return FunctionDeclarationKind.BV_SHL; + } else if (kind.equals(BITWUZLA_KIND_BV_SLE)) { + return FunctionDeclarationKind.BV_SLE; + } else if (kind.equals(BITWUZLA_KIND_BV_SLT)) { + return FunctionDeclarationKind.BV_SLT; + } else if (kind.equals(BITWUZLA_KIND_BV_SREM)) { + return FunctionDeclarationKind.BV_SREM; + } else if (kind.equals(BITWUZLA_KIND_BV_SUB)) { + return FunctionDeclarationKind.BV_SUB; + } else if (kind.equals(BITWUZLA_KIND_BV_UDIV)) { + return FunctionDeclarationKind.BV_UDIV; + } else if (kind.equals(BITWUZLA_KIND_BV_UGE)) { + return FunctionDeclarationKind.BV_UGE; + } else if (kind.equals(BITWUZLA_KIND_BV_UGT)) { + return FunctionDeclarationKind.BV_UGT; + } else if (kind.equals(BITWUZLA_KIND_BV_ULE)) { + return FunctionDeclarationKind.BV_ULE; + } else if (kind.equals(BITWUZLA_KIND_BV_ULT)) { + return FunctionDeclarationKind.BV_ULT; + } else if (kind.equals(BITWUZLA_KIND_BV_UREM)) { + return FunctionDeclarationKind.BV_UREM; + } else if (kind.equals(BITWUZLA_KIND_BV_EXTRACT)) { + return FunctionDeclarationKind.BV_EXTRACT; + } else if (kind.equals(BITWUZLA_KIND_BV_SIGN_EXTEND)) { + return FunctionDeclarationKind.BV_SIGN_EXTENSION; + } else if (kind.equals(BITWUZLA_KIND_BV_ZERO_EXTEND)) { + return FunctionDeclarationKind.BV_ZERO_EXTENSION; + } else if (kind.equals(BITWUZLA_KIND_FP_ABS)) { + return FunctionDeclarationKind.FP_ABS; + } else if (kind.equals(BITWUZLA_KIND_FP_ADD)) { + return FunctionDeclarationKind.FP_ADD; + } else if (kind.equals(BITWUZLA_KIND_FP_DIV)) { + return FunctionDeclarationKind.FP_DIV; + } else if (kind.equals(BITWUZLA_KIND_FP_EQUAL)) { + return FunctionDeclarationKind.FP_EQ; + } else if (kind.equals(BITWUZLA_KIND_FP_GEQ)) { + return FunctionDeclarationKind.FP_GE; + } else if (kind.equals(BITWUZLA_KIND_FP_GT)) { + return FunctionDeclarationKind.FP_GT; + } else if (kind.equals(BITWUZLA_KIND_FP_IS_INF)) { + return FunctionDeclarationKind.FP_IS_INF; + } else if (kind.equals(BITWUZLA_KIND_FP_IS_NAN)) { + return FunctionDeclarationKind.FP_IS_NAN; + } else if (kind.equals(BITWUZLA_KIND_FP_IS_NEG)) { + return FunctionDeclarationKind.FP_IS_NEGATIVE; + } else if (kind.equals(BITWUZLA_KIND_FP_IS_NORMAL)) { + return FunctionDeclarationKind.FP_IS_NORMAL; + } else if (kind.equals(BITWUZLA_KIND_FP_IS_SUBNORMAL)) { + return FunctionDeclarationKind.FP_IS_SUBNORMAL; + } else if (kind.equals(BITWUZLA_KIND_FP_IS_ZERO)) { + return FunctionDeclarationKind.FP_IS_ZERO; + } else if (kind.equals(BITWUZLA_KIND_FP_LEQ)) { + return FunctionDeclarationKind.FP_LE; + } else if (kind.equals(BITWUZLA_KIND_FP_LT)) { + return FunctionDeclarationKind.FP_LT; + } else if (kind.equals(BITWUZLA_KIND_FP_MAX)) { + return FunctionDeclarationKind.FP_MAX; + } else if (kind.equals(BITWUZLA_KIND_FP_MIN)) { + return FunctionDeclarationKind.FP_MIN; + } else if (kind.equals(BITWUZLA_KIND_FP_MUL)) { + return FunctionDeclarationKind.FP_MUL; + } else if (kind.equals(BITWUZLA_KIND_FP_NEG)) { + return FunctionDeclarationKind.FP_NEG; + } else if (kind.equals(BITWUZLA_KIND_FP_RTI)) { + return FunctionDeclarationKind.FP_ROUND_TO_INTEGRAL; + } else if (kind.equals(BITWUZLA_KIND_FP_SQRT)) { + return FunctionDeclarationKind.FP_SQRT; + } else if (kind.equals(BITWUZLA_KIND_FP_SUB)) { + return FunctionDeclarationKind.FP_SUB; + } else if (kind.equals(BITWUZLA_KIND_FP_TO_FP_FROM_BV)) { + return FunctionDeclarationKind.BV_UCASTTO_FP; + } else if (kind.equals(BITWUZLA_KIND_FP_TO_FP_FROM_FP)) { + return FunctionDeclarationKind.FP_CASTTO_FP; + } else if (kind.equals(BITWUZLA_KIND_FP_TO_FP_FROM_SBV)) { + return FunctionDeclarationKind.BV_SCASTTO_FP; + } else if (kind.equals(BITWUZLA_KIND_FP_TO_FP_FROM_UBV)) { + return FunctionDeclarationKind.BV_UCASTTO_FP; + } else if (kind.equals(BITWUZLA_KIND_FP_TO_SBV)) { + return FunctionDeclarationKind.FP_CASTTO_SBV; + } else if (kind.equals(BITWUZLA_KIND_FP_TO_UBV)) { + return FunctionDeclarationKind.FP_CASTTO_UBV; + } else if (kind.equals(BITWUZLA_KIND_BV_XOR)) { + return FunctionDeclarationKind.BV_XOR; + } + throw new UnsupportedOperationException("Can not discern formula kind " + kind); + } + + @SuppressWarnings("unchecked") + @Override + public T encapsulate(FormulaType pType, Long pTerm) { + assert pType.equals(getFormulaType(pTerm)) + : String.format( + "Trying to encapsulate formula of type %s as %s", getFormulaType(pTerm), pType); + if (pType.isBooleanType()) { + return (T) new BitwuzlaBooleanFormula(pTerm); + } else if (pType.isArrayType()) { + ArrayFormulaType arrFt = (ArrayFormulaType) pType; + return (T) new BitwuzlaArrayFormula<>(pTerm, arrFt.getIndexType(), arrFt.getElementType()); + } else if (pType.isBitvectorType()) { + return (T) new BitwuzlaBitvectorFormula(pTerm); + } else if (pType.isFloatingPointType()) { + return (T) new BitwuzlaFloatingPointFormula(pTerm); + } else if (pType.isFloatingPointRoundingModeType()) { + return (T) new BitwuzlaFloatingPointRoundingModeFormula(pTerm); + } + throw new IllegalArgumentException("Cannot create formulas of type " + pType + " in Bitwuzla"); + } + + @SuppressWarnings("unchecked") + @Override + public FormulaType getFormulaType(T pFormula) { + long sort = BitwuzlaJNI.bitwuzla_term_get_sort(extractInfo(pFormula)); + if (pFormula instanceof BitvectorFormula) { + checkArgument( + BitwuzlaJNI.bitwuzla_sort_is_bv(sort), + "BitvectorFormula with type missmatch: %s", + pFormula); + return (FormulaType) + FormulaType.getBitvectorTypeWithSize( + Math.toIntExact(BitwuzlaJNI.bitwuzla_sort_bv_get_size(sort))); + } else if (pFormula instanceof ArrayFormula) { + FormulaType arrayIndexType = getArrayFormulaIndexType((ArrayFormula) pFormula); + FormulaType arrayElementType = getArrayFormulaElementType((ArrayFormula) pFormula); + return (FormulaType) FormulaType.getArrayType(arrayIndexType, arrayElementType); + } else if (pFormula instanceof FloatingPointFormula) { + if (!BitwuzlaJNI.bitwuzla_sort_is_fp(sort)) { + throw new IllegalArgumentException( + "FloatingPointFormula with actual type " + + BitwuzlaJNI.bitwuzla_sort_to_string(sort) + + ": " + + pFormula); + } + int exp = (int) BitwuzlaJNI.bitwuzla_sort_fp_get_exp_size(sort); + int man = (int) BitwuzlaJNI.bitwuzla_sort_fp_get_sig_size(sort) - 1; + return (FormulaType) FormulaType.getFloatingPointType(exp, man); + } else if (BitwuzlaJNI.bitwuzla_sort_is_rm(sort)) { + return (FormulaType) FormulaType.FloatingPointRoundingModeType; + } + return super.getFormulaType(pFormula); + } + + @Override + public FormulaType getFormulaType(Long formula) { + long pType = BitwuzlaJNI.bitwuzla_term_get_sort(formula); + return bitwuzlaSortToType(pType); + } + + private BigDecimal parseIEEEbinaryFP(long pTerm) { + // The Bitwuzla string for FPs is always in binary, regardless of the second argument. + + String fp = BitwuzlaJNI.bitwuzla_term_value_get_str(pTerm); + + if (fp.length() == 32) { + float result = Float.intBitsToFloat(Integer.parseUnsignedInt(fp, 2)); + return new BigDecimal(result); + } else if (fp.length() == 64) { + double result = Double.longBitsToDouble(Long.parseUnsignedLong(fp, 2)); + return new BigDecimal(result); + } else { + throw new UnsupportedOperationException( + "Visitor can only visit constant FPs of 32 or 64 " + "bits."); + } + + // String fpSMTLIB = bitwuzlaJNI.bitwuzla_term_to_string(pTerm); + // String[] mySplit = fpSMTLIB.split(" #b"); + // mySplit[3] = mySplit[3].replace(")", ""); + // double result = calculateDecimal(mySplit[3], mySplit[2], mySplit[1]); + } + + @Override + public R visit(FormulaVisitor visitor, Formula formula, Long f) + throws UnsupportedOperationException { + BitwuzlaKind kind = BitwuzlaKind.swigToEnum(BitwuzlaJNI.bitwuzla_term_get_kind(f)); + if (termIsConstant(f)) { + return visitor.visitConstant(formula, convertValue(f)); + + } else if (BitwuzlaJNI.bitwuzla_term_is_fp_value(f)) { + return visitor.visitConstant(formula, parseIEEEbinaryFP(f)); + + } else if (BitwuzlaJNI.bitwuzla_term_is_const(f)) { + String name = BitwuzlaJNI.bitwuzla_term_get_symbol(f); + return visitor.visitFreeVariable(formula, name); + + } else if (BitwuzlaJNI.bitwuzla_term_is_var(f)) { + String name = BitwuzlaJNI.bitwuzla_term_get_symbol(f); + long sort = BitwuzlaJNI.bitwuzla_term_get_sort(f); + long originalVar = formulaCache.get(name, sort); + return visitor.visitBoundVariable(encapsulate(getFormulaType(originalVar), originalVar), 0); + + } else if (kind.equals(BITWUZLA_KIND_EXISTS) || kind.equals(BITWUZLA_KIND_FORALL)) { + long[] children = BitwuzlaJNI.bitwuzla_term_get_children(f, new long[1]); + // QUANTIFIER: replace bound variable with free variable for visitation + int size = children.length; + assert children.length == 2; + long bodyUnSub = children[size - 1]; + List freeEncVars = new ArrayList<>(); + // The first length - 2 elements are bound vars, and the last element is the body + long[] boundVars = new long[size - 1]; + long[] freeVars = new long[size - 1]; + for (int i = 0; i < size - 1; i++) { + long boundVar = children[i]; + boundVars[i] = boundVar; + String name = BitwuzlaJNI.bitwuzla_term_get_symbol(boundVar); + assert name != null; + long sort = BitwuzlaJNI.bitwuzla_term_get_sort(boundVar); + long freeVar; + if (formulaCache.contains(name, sort)) { + freeVar = formulaCache.get(name, sort); + } else { + // no free var existing (e.g. from parsing), create a new one + freeVar = makeVariable(sort, name); + } + freeVars[i] = freeVar; + freeEncVars.add(encapsulate(getFormulaType(freeVar), freeVar)); + } + + long bodySubbed = BitwuzlaJNI.bitwuzla_substitute_term(bodyUnSub, 1, boundVars, freeVars); + + Quantifier quant = kind.equals(BITWUZLA_KIND_EXISTS) ? Quantifier.EXISTS : Quantifier.FORALL; + return visitor.visitQuantifier( + (BooleanFormula) formula, quant, freeEncVars, encapsulateBoolean(bodySubbed)); + + } else { + long[] args = BitwuzlaJNI.bitwuzla_term_get_children(f, new long[1]); + ImmutableList.Builder arguments = ImmutableList.builder(); + ImmutableList.Builder> argumentTypes = ImmutableList.builder(); + + String name = BitwuzlaJNI.bitwuzla_term_get_symbol(f); + + BitwuzlaDeclaration decl = null; + for (int i = 0; i < args.length; i++) { + long argument = args[i]; + if (kind == BITWUZLA_KIND_APPLY && i == 0) { + // UFs carry the decl in the first child and the decl has the name + decl = new BitwuzlaDeclaration(argument, false); + name = BitwuzlaJNI.bitwuzla_term_get_symbol(argument); + continue; + } + FormulaType type = getFormulaType(argument); + arguments.add(encapsulate(type, argument)); + argumentTypes.add(type); + } + + if (name == null) { + name = BitwuzlaJNI.bitwuzla_kind_to_string(BitwuzlaJNI.bitwuzla_term_get_kind(f)); + } + if (decl == null) { + decl = new BitwuzlaDeclaration(BitwuzlaJNI.bitwuzla_term_get_kind(f), true); + } + if (BitwuzlaJNI.bitwuzla_term_is_indexed(f)) { + // We need to retain the original formula as the declaration for indexed formulas, + // otherwise we loose the index info, but we also need to know if its a kind or term + decl = new BitwuzlaDeclaration(f, false); + } + + return visitor.visitFunction( + formula, + arguments.build(), + FunctionDeclarationImpl.of( + name, getDeclarationKind(f), argumentTypes.build(), getFormulaType(f), decl)); + } + } + + private boolean termIsConstant(long term) { + return BITWUZLA_KIND_VALUE.swigValue() == BitwuzlaJNI.bitwuzla_term_get_kind(term); + } + + @Override + public Long callFunctionImpl(BitwuzlaDeclaration declaration, List args) { + // For UFs the declaration needs to be a const wrapping of the function sort + // For all other functions it needs to be the kind + // BUT, we can never use a bitwuzla_term_is... function on a KIND + if (!declaration.isKind() && BitwuzlaJNI.bitwuzla_term_is_indexed(declaration.getTerm())) { + // The term might be indexed, then we need index creation + long term = declaration.getTerm(); + int properKind = BitwuzlaJNI.bitwuzla_term_get_kind(term); + if (BitwuzlaKind.swigToEnum(properKind) == BITWUZLA_KIND_BV_ZERO_EXTEND) { + System.out.println(); + } + long[] indices = BitwuzlaJNI.bitwuzla_term_get_indices(term, new long[1]); + return BitwuzlaJNI.bitwuzla_mk_term_indexed( + properKind, + args.size(), + args.stream().mapToLong(Long::longValue).toArray(), + indices.length, + indices); + } + + if (!declaration.isKind() && BitwuzlaJNI.bitwuzla_term_is_fun(declaration.getTerm())) { + long[] functionAndArgs = + LongStream.concat( + LongStream.of(declaration.getTerm()), args.stream().mapToLong(Long::longValue)) + .toArray(); + return BitwuzlaJNI.bitwuzla_mk_term( + BITWUZLA_KIND_APPLY.swigValue(), functionAndArgs.length, functionAndArgs); + } + + assert declaration.isKind(); + long declKind = declaration.getKind(); + + return BitwuzlaJNI.bitwuzla_mk_term( + (int) declKind, args.size(), args.stream().mapToLong(Long::longValue).toArray()); + } + + @Override + public BitwuzlaDeclaration declareUFImpl(String name, Long pReturnType, List pArgTypes) { + if (pArgTypes.isEmpty()) { + // Bitwuzla does not support UFs with no args, so we make a variable + // TODO: implement + throw new UnsupportedOperationException("Bitwuzla does not support 0 arity UFs."); + } + long functionSort = + BitwuzlaJNI.bitwuzla_mk_fun_sort( + pArgTypes.size(), pArgTypes.stream().mapToLong(Long::longValue).toArray(), pReturnType); + + Long maybeFormula = formulaCache.get(name, functionSort); + if (maybeFormula != null) { + return new BitwuzlaDeclaration(maybeFormula, false); + } + + long uf = BitwuzlaJNI.bitwuzla_mk_const(functionSort, name); + formulaCache.put(name, functionSort, uf); + return new BitwuzlaDeclaration(uf, false); + } + + @Override + protected BitwuzlaDeclaration getBooleanVarDeclarationImpl(Long pLong) { + long kind = BitwuzlaJNI.bitwuzla_term_get_kind(pLong); + + // CONSTANTS are "variables" and Kind.VARIABLES are bound variables in for example quantifiers + assert kind == BITWUZLA_KIND_APPLY.swigValue() || kind == BITWUZLA_KIND_CONSTANT.swigValue() + : BitwuzlaJNI.bitwuzla_term_to_string(kind); + if (kind == BITWUZLA_KIND_APPLY.swigValue()) { + long[] size = new long[1]; + long[] pChildren = BitwuzlaJNI.bitwuzla_term_get_children(pLong, size); + // Returns pointer to Uninterpreted Function used in Apply + return new BitwuzlaDeclaration(pChildren[0], false); + } else { + return new BitwuzlaDeclaration(pLong, true); + } + } + + @Override + public Long extractInfo(Formula pT) { + return BitwuzlaFormulaManager.getBitwuzlaTerm(pT); + } + + @Override + public BooleanFormula encapsulateBoolean(Long pTerm) { + assert getFormulaType(pTerm).isBooleanType(); + return new BitwuzlaBooleanFormula(pTerm); + } + + protected Table getCache() { + return formulaCache; + } + + // True if the entered String has an existing variable in the cache. + protected boolean formulaCacheContains(String variable) { + // There is always only 1 type permitted per variable + return formulaCache.containsRow(variable); + } + + // Optional that contains the variable to the entered String if there is one. + protected Optional getFormulaFromCache(String variable) { + Iterator> entrySetIter = formulaCache.row(variable).entrySet().iterator(); + if (entrySetIter.hasNext()) { + // If there is a non empty row for an entry, there is only one entry + return Optional.of(entrySetIter.next().getValue()); + } + return Optional.empty(); + } + + @Override + public Object convertValue(Long term) { + String value; + long sort = BitwuzlaJNI.bitwuzla_term_get_sort(term); + if (BitwuzlaJNI.bitwuzla_term_is_const(term)) { + return null; + } + if (BitwuzlaJNI.bitwuzla_sort_is_fun(sort)) { + // TODO: this is wrong + throw new AssertionError("Error: Unknown sort and term"); + } else { + value = BitwuzlaJNI.bitwuzla_term_to_string(term); + if (value.startsWith("#b")) { + // Bitvectors in Bitwuzla start with a #b + return new BigInteger(value.substring(2), 2); + } else if (value.equals("true")) { + return true; + } else if (value.equals("false")) { + return false; + } else if (value.startsWith("(fp")) { + return value + .replace("(fp", "") + .replace(")", "") + .replace("#b", "") + .replace("#b", "") + .replace("#b", "") + .strip(); + } else if (BitwuzlaJNI.bitwuzla_sort_is_rm(sort)) { + return value; + } + } + + throw new AssertionError( + "Error: Could not convert term to value; Unknown sort and term. " + + "Value: " + + BitwuzlaJNI.bitwuzla_term_to_string(term)); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaFormulaManager.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaFormulaManager.java new file mode 100644 index 0000000000..da61462db4 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaFormulaManager.java @@ -0,0 +1,99 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import com.google.common.base.Preconditions; +import java.io.IOException; +import org.sosy_lab.common.Appender; +import org.sosy_lab.common.Appenders; +import org.sosy_lab.java_smt.api.BooleanFormula; +import org.sosy_lab.java_smt.api.Formula; +import org.sosy_lab.java_smt.basicimpl.AbstractFormulaManager; + +final class BitwuzlaFormulaManager + extends AbstractFormulaManager { + + BitwuzlaFormulaManager( + BitwuzlaFormulaCreator pFormulaCreator, + BitwuzlaUFManager pFunctionManager, + BitwuzlaBooleanFormulaManager pBooleanManager, + BitwuzlaBitvectorFormulaManager pBitvectorManager, + BitwuzlaQuantifiedFormulaManager pQuantifierManager, + BitwuzlaFloatingPointManager pFloatingPointManager, + BitwuzlaArrayFormulaManager pArrayManager) { + super( + pFormulaCreator, + pFunctionManager, + pBooleanManager, + null, + null, + pBitvectorManager, + pFloatingPointManager, + pQuantifierManager, + pArrayManager, + null, + null, + null); + } + + @Override + public BooleanFormula parse(String s) throws IllegalArgumentException { + if (s.contains("(check-sat)")) { + s = s.replace("(check-sat)", ""); + } + if (s.contains("(exit)")) { + s = s.replace("(exit)", ""); + } + long[] terms = BitwuzlaJNI.parse(s); + Preconditions.checkArgument(terms != null, "Could not parse input string \"%s\"", s); + assert terms != null; + // AND all the terms + Long retForm; + if (terms.length > 1) { + retForm = + BitwuzlaJNI.bitwuzla_mk_term( + BitwuzlaKind.BITWUZLA_KIND_AND.swigValue(), terms.length, terms); + } else { + retForm = terms[0]; + } + assert BitwuzlaJNI.bitwuzla_term_is_bool(retForm); + return super.getFormulaCreator().encapsulateBoolean(retForm); + } + + @Override + public Appender dumpFormula(Long pTerm) { + // There are 2 ways of SMT2 printing in Bitwuzla, bitwuzla_term_print() and + // bitwuzla_term_print_fmt(), which print a single formula, and bitwuzla_print_formula(), + // which prints the complete assertion stack of the bitwuzla instance given to the function. + // Only bitwuzla_print_formula() gives us the proper SMT2 format, with (check-sat) etc. + // Note: bitwuzla_print_formula() is wrapped in dump_assertions_smt2() + return new Appenders.AbstractAppender() { + @Override + public void appendTo(Appendable out) throws IOException { + long printCtx = getFormulaCreator().getEnv(); + BitwuzlaJNI.bitwuzla_push(printCtx, 1); + BitwuzlaJNI.bitwuzla_assert(printCtx, pTerm); + String dump = BitwuzlaJNI.dump_assertions_smt2(printCtx, 10); + BitwuzlaJNI.bitwuzla_pop(printCtx, 1); + // Bitwuzla prints (check-sat)\n(exit)\n in the end. We remove that. + if (dump.contains("(check-sat)\n")) { + dump = dump.replace("(check-sat)", ""); + } + if (dump.contains("(exit)")) { + dump = dump.replace("(exit)", ""); + } + out.append(dump); + } + }; + } + + static long getBitwuzlaTerm(Formula pT) { + return ((BitwuzlaFormula) pT).getTerm(); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaJNI.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaJNI.java new file mode 100644 index 0000000000..3939559601 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaJNI.java @@ -0,0 +1,758 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +@SuppressWarnings({"unused", "checkstyle:methodname", "checkstyle:parametername"}) +public class BitwuzlaJNI { + private BitwuzlaJNI() {} + + public static final native long new_BitwuzlaTermArray(int jarg1); + + public static final native void delete_BitwuzlaTermArray(long jarg1); + + public static final native long BitwuzlaTermArray_getitem(long jarg1, int jarg2); + + public static final native void BitwuzlaTermArray_setitem(long jarg1, int jarg2, long jarg3); + + public static final native long new_BitwuzlaSortArray(int jarg1); + + public static final native void delete_BitwuzlaSortArray(long jarg1); + + public static final native long BitwuzlaSortArray_getitem(long jarg1, int jarg2); + + public static final native void BitwuzlaSortArray_setitem(long jarg1, int jarg2, long jarg3); + + public static final native long new_uint64_tArray(int jarg1); + + public static final native void delete_uint64_tArray(long jarg1); + + public static final native long uint64_tArray_getitem(long jarg1, int jarg2); + + public static final native void uint64_tArray_setitem(long jarg1, int jarg2, long jarg3); + + public static final native int true_get(); + + public static final native int false_get(); + + public static final native int __bool_true_false_are_defined_get(); + + public static final native int _STDIO_H_get(); + + public static final native int _FEATURES_H_get(); + + public static final native int _DEFAULT_SOURCE_get(); + + public static final native int __GLIBC_USE_ISOC2X_get(); + + public static final native int __USE_POSIX_IMPLICITLY_get(); + + public static final native int _POSIX_SOURCE_get(); + + public static final native int _POSIX_C_SOURCE_get(); + + public static final native int __USE_POSIX_get(); + + public static final native int __USE_POSIX2_get(); + + public static final native int __USE_POSIX199309_get(); + + public static final native int __USE_POSIX199506_get(); + + public static final native int __USE_XOPEN2K_get(); + + public static final native int __USE_ISOC95_get(); + + public static final native int __USE_ISOC99_get(); + + public static final native int __USE_XOPEN2K8_get(); + + public static final native int _ATFILE_SOURCE_get(); + + public static final native int __WORDSIZE_get(); + + public static final native int __WORDSIZE32_SIZE_ULONG_get(); + + public static final native int __WORDSIZE32_PTRDIFF_LONG_get(); + + public static final native int __WORDSIZE_TIME64_COMPAT32_get(); + + public static final native int __TIMESIZE_get(); + + public static final native int __USE_MISC_get(); + + public static final native int __USE_ATFILE_get(); + + public static final native int __USE_FORTIFY_LEVEL_get(); + + public static final native int __GLIBC_USE_DEPRECATED_GETS_get(); + + public static final native int __GLIBC_USE_DEPRECATED_SCANF_get(); + + public static final native int _STDC_PREDEF_H_get(); + + public static final native int __STDC_IEC_559___get(); + + public static final native int __STDC_IEC_60559_BFP___get(); + + public static final native int __STDC_IEC_559_COMPLEX___get(); + + public static final native int __STDC_IEC_60559_COMPLEX___get(); + + public static final native int __STDC_ISO_10646___get(); + + public static final native int __GNU_LIBRARY___get(); + + public static final native int __GLIBC___get(); + + public static final native int __GLIBC_MINOR___get(); + + public static final native int _SYS_CDEFS_H_get(); + + public static final native int __glibc_c99_flexarr_available_get(); + + public static final native int __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI_get(); + + public static final native int __HAVE_GENERIC_SELECTION_get(); + + public static final native int __GLIBC_USE_LIB_EXT2_get(); + + public static final native int __GLIBC_USE_IEC_60559_BFP_EXT_get(); + + public static final native int __GLIBC_USE_IEC_60559_BFP_EXT_C2X_get(); + + public static final native int __GLIBC_USE_IEC_60559_EXT_get(); + + public static final native int __GLIBC_USE_IEC_60559_FUNCS_EXT_get(); + + public static final native int __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X_get(); + + public static final native int __GLIBC_USE_IEC_60559_TYPES_EXT_get(); + + public static final native int _BITS_TYPES_H_get(); + + public static final native int _BITS_TYPESIZES_H_get(); + + public static final native int __RLIM_T_MATCHES_RLIM64_T_get(); + + public static final native int __STATFS_MATCHES_STATFS64_get(); + + public static final native int __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64_get(); + + public static final native int __FD_SETSIZE_get(); + + public static final native int _BITS_TIME64_H_get(); + + public static final native long new___fpos64_t(); + + public static final native void delete___fpos64_t(long jarg1); + + public static final native int ____FILE_defined_get(); + + public static final native int __FILE_defined_get(); + + public static final native int __struct_FILE_defined_get(); + + public static final native long new__IO_FILE(); + + public static final native void delete__IO_FILE(long jarg1); + + public static final native int _IO_EOF_SEEN_get(); + + public static final native int _IO_ERR_SEEN_get(); + + public static final native int _IO_USER_LOCK_get(); + + public static final native int _IOFBF_get(); + + public static final native int _IOLBF_get(); + + public static final native int _IONBF_get(); + + public static final native int BUFSIZ_get(); + + public static final native int EOF_get(); + + public static final native int SEEK_SET_get(); + + public static final native int SEEK_CUR_get(); + + public static final native int SEEK_END_get(); + + public static final native String P_tmpdir_get(); + + public static final native int _BITS_STDIO_LIM_H_get(); + + public static final native int L_tmpnam_get(); + + public static final native int TMP_MAX_get(); + + public static final native int FILENAME_MAX_get(); + + public static final native int L_ctermid_get(); + + public static final native int FOPEN_MAX_get(); + + public static final native long stdin_get(); + + public static final native long stdout_get(); + + public static final native long stderr_get(); + + public static final native int remove(String jarg1); + + public static final native int rename(String jarg1, String jarg2); + + public static final native int renameat(int jarg1, String jarg2, int jarg3, String jarg4); + + public static final native long tmpfile(); + + public static final native String tmpnam(String jarg1); + + public static final native String tmpnam_r(String jarg1); + + public static final native String tempnam(String jarg1, String jarg2); + + public static final native long fopen(String jarg1, String jarg2); + + public static final native long fdopen(int jarg1, String jarg2); + + public static final native long fmemopen(long jarg1, long jarg2, String jarg3); + + public static final native long open_memstream(long jarg1, long jarg2); + + public static final native int printf(String jarg1); + + public static final native int sprintf(String jarg1, String jarg2); + + public static final native int vprintf(String jarg1, long jarg2); + + public static final native int vsprintf(String jarg1, String jarg2, long jarg3); + + public static final native int snprintf(String jarg1, long jarg2, String jarg3); + + public static final native int vsnprintf(String jarg1, long jarg2, String jarg3, long jarg4); + + public static final native int vdprintf(int jarg1, String jarg2, long jarg3); + + public static final native int dprintf(int jarg1, String jarg2); + + public static final native int scanf(String jarg1); + + public static final native int sscanf(String jarg1, String jarg2); + + public static final native int __HAVE_FLOAT128_get(); + + public static final native int __HAVE_DISTINCT_FLOAT128_get(); + + public static final native int __HAVE_FLOAT64X_get(); + + public static final native int __HAVE_FLOAT64X_LONG_DOUBLE_get(); + + public static final native int __HAVE_FLOAT16_get(); + + public static final native int __HAVE_FLOAT32_get(); + + public static final native int __HAVE_FLOAT64_get(); + + public static final native int __HAVE_FLOAT32X_get(); + + public static final native int __HAVE_FLOAT128X_get(); + + public static final native int __HAVE_DISTINCT_FLOAT16_get(); + + public static final native int __HAVE_DISTINCT_FLOAT32_get(); + + public static final native int __HAVE_DISTINCT_FLOAT64_get(); + + public static final native int __HAVE_DISTINCT_FLOAT32X_get(); + + public static final native int __HAVE_DISTINCT_FLOAT64X_get(); + + public static final native int __HAVE_DISTINCT_FLOAT128X_get(); + + public static final native int __HAVE_FLOATN_NOT_TYPEDEF_get(); + + public static final native int __isoc99_scanf(String jarg1); + + public static final native int __isoc99_sscanf(String jarg1, String jarg2); + + public static final native int vscanf(String jarg1, long jarg2); + + public static final native int vsscanf(String jarg1, String jarg2, long jarg3); + + public static final native int __isoc99_vscanf(String jarg1, long jarg2); + + public static final native int __isoc99_vsscanf(String jarg1, String jarg2, long jarg3); + + public static final native int getchar(); + + public static final native int getchar_unlocked(); + + public static final native int putchar(int jarg1); + + public static final native int putchar_unlocked(int jarg1); + + public static final native int puts(String jarg1); + + public static final native void perror(String jarg1); + + public static final native long popen(String jarg1, String jarg2); + + public static final native String ctermid(String jarg1); + + public static final native int BITWUZLA_SAT_get(); + + public static final native int BITWUZLA_UNSAT_get(); + + public static final native int BITWUZLA_UNKNOWN_get(); + + public static final native int BITWUZLA_RM_RNE_get(); + + public static final native int BITWUZLA_RM_RNA_get(); + + public static final native int BITWUZLA_RM_RTN_get(); + + public static final native int BITWUZLA_RM_RTP_get(); + + public static final native int BITWUZLA_RM_RTZ_get(); + + public static final native int BITWUZLA_RM_MAX_get(); + + public static final native int BITWUZLA_KIND_CONSTANT_get(); + + public static final native String bitwuzla_copyright(); + + public static final native String bitwuzla_version(); + + public static final native String bitwuzla_git_id(); + + public static final native void BitwuzlaOptionInfo_opt_set( + long jarg1, BitwuzlaOptionInfo jarg1_, int jarg2); + + public static final native int BitwuzlaOptionInfo_opt_get(long jarg1, BitwuzlaOptionInfo jarg1_); + + public static final native void BitwuzlaOptionInfo_shrt_set( + long jarg1, BitwuzlaOptionInfo jarg1_, String jarg2); + + public static final native String BitwuzlaOptionInfo_shrt_get( + long jarg1, BitwuzlaOptionInfo jarg1_); + + public static final native void BitwuzlaOptionInfo_lng_set( + long jarg1, BitwuzlaOptionInfo jarg1_, String jarg2); + + public static final native String BitwuzlaOptionInfo_lng_get( + long jarg1, BitwuzlaOptionInfo jarg1_); + + public static final native void BitwuzlaOptionInfo_description_set( + long jarg1, BitwuzlaOptionInfo jarg1_, String jarg2); + + public static final native String BitwuzlaOptionInfo_description_get( + long jarg1, BitwuzlaOptionInfo jarg1_); + + public static final native void BitwuzlaOptionInfo_is_numeric_set( + long jarg1, BitwuzlaOptionInfo jarg1_, boolean jarg2); + + public static final native boolean BitwuzlaOptionInfo_is_numeric_get( + long jarg1, BitwuzlaOptionInfo jarg1_); + + public static final native void BitwuzlaOptionInfo_numeric_set( + long jarg1, BitwuzlaOptionInfo jarg1_, long jarg2, NumericValue jarg2_); + + public static final native long BitwuzlaOptionInfo_numeric_get( + long jarg1, BitwuzlaOptionInfo jarg1_); + + public static final native long BitwuzlaOptionInfo_mode_get( + long jarg1, BitwuzlaOptionInfo jarg1_); + + public static final native long new_BitwuzlaOptionInfo(); + + public static final native void delete_BitwuzlaOptionInfo(long jarg1); + + public static final native void NumericValue_cur_set(long jarg1, NumericValue jarg1_, long jarg2); + + public static final native long NumericValue_cur_get(long jarg1, NumericValue jarg1_); + + public static final native void NumericValue_dflt_set( + long jarg1, NumericValue jarg1_, long jarg2); + + public static final native long NumericValue_dflt_get(long jarg1, NumericValue jarg1_); + + public static final native void NumericValue_min_set(long jarg1, NumericValue jarg1_, long jarg2); + + public static final native long NumericValue_min_get(long jarg1, NumericValue jarg1_); + + public static final native void NumericValue_max_set(long jarg1, NumericValue jarg1_, long jarg2); + + public static final native long NumericValue_max_get(long jarg1, NumericValue jarg1_); + + public static final native long new_NumericValue(); + + public static final native void delete_NumericValue(long jarg1); + + public static final native long new_ModeValue(); + + public static final native void delete_ModeValue(long jarg1); + + public static final native long bitwuzla_options_new(); + + public static final native void bitwuzla_options_delete(long jarg1); + + public static final native boolean bitwuzla_option_is_valid(long jarg1, String jarg2); + + public static final native boolean bitwuzla_option_is_numeric(long jarg1, int jarg2); + + public static final native boolean bitwuzla_option_is_mode(long jarg1, int jarg2); + + public static final native void bitwuzla_set_option(long jarg1, int jarg2, long jarg3); + + public static final native void bitwuzla_set_option_mode(long jarg1, int jarg2, String jarg3); + + public static final native long bitwuzla_get_option(long jarg1, int jarg2); + + public static final native String bitwuzla_get_option_mode(long jarg1, int jarg2); + + public static final native void bitwuzla_get_option_info( + long jarg1, int jarg2, long jarg3, BitwuzlaOptionInfo jarg3_); + + public static final native String bitwuzla_result_to_string(int jarg1); + + public static final native String bitwuzla_rm_to_string(int jarg1); + + public static final native String bitwuzla_kind_to_string(int jarg1); + + public static final native long bitwuzla_sort_hash(long jarg1); + + public static final native long bitwuzla_sort_bv_get_size(long jarg1); + + public static final native long bitwuzla_sort_fp_get_exp_size(long jarg1); + + public static final native long bitwuzla_sort_fp_get_sig_size(long jarg1); + + public static final native long bitwuzla_sort_array_get_index(long jarg1); + + public static final native long bitwuzla_sort_array_get_element(long jarg1); + + public static final native long bitwuzla_sort_fun_get_domain_sorts(long jarg1, long[] jarg2); + + public static final native long bitwuzla_sort_fun_get_codomain(long jarg1); + + public static final native long bitwuzla_sort_fun_get_arity(long jarg1); + + public static final native String bitwuzla_sort_get_uninterpreted_symbol(long jarg1); + + public static final native boolean bitwuzla_sort_is_equal(long jarg1, long jarg2); + + public static final native boolean bitwuzla_sort_is_array(long jarg1); + + public static final native boolean bitwuzla_sort_is_bool(long jarg1); + + public static final native boolean bitwuzla_sort_is_bv(long jarg1); + + public static final native boolean bitwuzla_sort_is_fp(long jarg1); + + public static final native boolean bitwuzla_sort_is_fun(long jarg1); + + public static final native boolean bitwuzla_sort_is_rm(long jarg1); + + public static final native boolean bitwuzla_sort_is_uninterpreted(long jarg1); + + public static final native String bitwuzla_sort_to_string(long jarg1); + + public static final native long bitwuzla_term_hash(long jarg1); + + public static final native int bitwuzla_term_get_kind(long jarg1); + + public static final native long[] bitwuzla_term_get_children(long jarg1, long[] jarg2); + + public static final native long[] bitwuzla_term_get_indices(long jarg1, long[] jarg2); + + public static final native boolean bitwuzla_term_is_indexed(long jarg1); + + public static final native long bitwuzla_term_get_sort(long jarg1); + + public static final native long bitwuzla_term_array_get_index_sort(long jarg1); + + public static final native long bitwuzla_term_array_get_element_sort(long jarg1); + + public static final native long bitwuzla_term_fun_get_domain_sorts(long jarg1, long[] jarg2); + + public static final native long bitwuzla_term_fun_get_codomain_sort(long jarg1); + + public static final native long bitwuzla_term_bv_get_size(long jarg1); + + public static final native long bitwuzla_term_fp_get_exp_size(long jarg1); + + public static final native long bitwuzla_term_fp_get_sig_size(long jarg1); + + public static final native long bitwuzla_term_fun_get_arity(long jarg1); + + public static final native String bitwuzla_term_get_symbol(long jarg1); + + public static final native boolean bitwuzla_term_is_equal_sort(long jarg1, long jarg2); + + public static final native boolean bitwuzla_term_is_array(long jarg1); + + public static final native boolean bitwuzla_term_is_const(long jarg1); + + public static final native boolean bitwuzla_term_is_fun(long jarg1); + + public static final native boolean bitwuzla_term_is_var(long jarg1); + + public static final native boolean bitwuzla_term_is_value(long jarg1); + + public static final native boolean bitwuzla_term_is_bv_value(long jarg1); + + public static final native boolean bitwuzla_term_is_fp_value(long jarg1); + + public static final native boolean bitwuzla_term_is_rm_value(long jarg1); + + public static final native boolean bitwuzla_term_is_bool(long jarg1); + + public static final native boolean bitwuzla_term_is_bv(long jarg1); + + public static final native boolean bitwuzla_term_is_fp(long jarg1); + + public static final native boolean bitwuzla_term_is_rm(long jarg1); + + public static final native boolean bitwuzla_term_is_uninterpreted(long jarg1); + + public static final native boolean bitwuzla_term_is_true(long jarg1); + + public static final native boolean bitwuzla_term_is_false(long jarg1); + + public static final native boolean bitwuzla_term_is_bv_value_zero(long jarg1); + + public static final native boolean bitwuzla_term_is_bv_value_one(long jarg1); + + public static final native boolean bitwuzla_term_is_bv_value_ones(long jarg1); + + public static final native boolean bitwuzla_term_is_bv_value_min_signed(long jarg1); + + public static final native boolean bitwuzla_term_is_bv_value_max_signed(long jarg1); + + public static final native boolean bitwuzla_term_is_fp_value_pos_zero(long jarg1); + + public static final native boolean bitwuzla_term_is_fp_value_neg_zero(long jarg1); + + public static final native boolean bitwuzla_term_is_fp_value_pos_inf(long jarg1); + + public static final native boolean bitwuzla_term_is_fp_value_neg_inf(long jarg1); + + public static final native boolean bitwuzla_term_is_fp_value_nan(long jarg1); + + public static final native boolean bitwuzla_term_is_rm_value_rna(long jarg1); + + public static final native boolean bitwuzla_term_is_rm_value_rne(long jarg1); + + public static final native boolean bitwuzla_term_is_rm_value_rtn(long jarg1); + + public static final native boolean bitwuzla_term_is_rm_value_rtp(long jarg1); + + public static final native boolean bitwuzla_term_is_rm_value_rtz(long jarg1); + + public static final native boolean bitwuzla_term_value_get_bool(long jarg1); + + public static final native String bitwuzla_term_value_get_str(long jarg1); + + public static final native String bitwuzla_term_value_get_str_fmt(long jarg1, int jarg2); + + public static final native void bitwuzla_term_value_get_fp_ieee( + long jarg1, long jarg2, long jarg3, long jarg4, int jarg5); + + public static final native int bitwuzla_term_value_get_rm(long jarg1); + + public static final native String bitwuzla_term_to_string(long jarg1); + + public static final native String bitwuzla_term_to_string_fmt(long jarg1, int jarg2); + + public static final native long bitwuzla_new(long options); + + public static final native void bitwuzla_delete(long env); + + public static final native void bitwuzla_set_termination_callback( + long jarg1, long jarg2, long jarg3); + + public static final native long bitwuzla_get_termination_callback_state(long jarg1); + + public static final native void bitwuzla_set_abort_callback(long jarg1); + + public static final native void bitwuzla_push(long env, long numOfLevels); + + public static final native void bitwuzla_pop(long env, long numOfLevel); + + public static final native void bitwuzla_assert(long env, long jarg2); + + public static final native long bitwuzla_get_assertions(long jarg1, long[] jarg2); + + public static final native boolean bitwuzla_is_unsat_assumption(long jarg1, long jarg2); + + public static final native long bitwuzla_get_unsat_assumptions(long jarg1, long[] jarg2); + + public static final native long bitwuzla_get_unsat_core(long env, long[] jarg2); + + public static final native void bitwuzla_simplify(long jarg1); + + public static final native int bitwuzla_check_sat(long env); + + public static final native int bitwuzla_check_sat_assuming(long jarg1, long jarg2, long[] jarg3); + + public static final native long bitwuzla_get_value(long env, long term); + + public static final native void bitwuzla_get_statistics( + long jarg1, long jarg2, long jarg3, long[] jarg4); + + public static final native long bitwuzla_mk_array_sort(long index, long element); + + public static final native long bitwuzla_mk_bool_sort(); + + public static final native long bitwuzla_mk_bv_sort(long width); + + public static final native long bitwuzla_mk_fp_sort(long exponent, long significant); + + public static final native long bitwuzla_mk_fun_sort(long arity, long[] domain, long codomain); + + public static final native long bitwuzla_mk_rm_sort(); + + public static final native long bitwuzla_mk_uninterpreted_sort(String symbol); + + public static final native long bitwuzla_mk_true(); + + public static final native long bitwuzla_mk_false(); + + public static final native long bitwuzla_mk_bv_zero(long jarg1); + + public static final native long bitwuzla_mk_bv_one(long jarg1); + + public static final native long bitwuzla_mk_bv_ones(long jarg1); + + public static final native long bitwuzla_mk_bv_min_signed(long jarg1); + + public static final native long bitwuzla_mk_bv_max_signed(long jarg1); + + public static final native long bitwuzla_mk_fp_pos_zero(long jarg1); + + public static final native long bitwuzla_mk_fp_neg_zero(long jarg1); + + public static final native long bitwuzla_mk_fp_pos_inf(long jarg1); + + public static final native long bitwuzla_mk_fp_neg_inf(long jarg1); + + public static final native long bitwuzla_mk_fp_nan(long jarg1); + + public static final native long bitwuzla_mk_bv_value(long jarg1, String jarg2, int jarg3); + + public static final native long bitwuzla_mk_bv_value_uint64(long jarg1, long jarg2); + + public static final native long bitwuzla_mk_bv_value_int64(long jarg1, int jarg2); + + public static final native long bitwuzla_mk_fp_value(long jarg1, long jarg2, long jarg3); + + public static final native long bitwuzla_mk_fp_from_real(long jarg1, long jarg2, String jarg3); + + public static final native long bitwuzla_mk_fp_from_rational( + long jarg1, long jarg2, String jarg3, String jarg4); + + public static final native long bitwuzla_mk_rm_value(int jarg1); + + public static final native long bitwuzla_mk_term1(int jarg1, long jarg2); + + public static final native long bitwuzla_mk_term2(int jarg1, long jarg2, long jarg3); + + public static final native long bitwuzla_mk_term3(int jarg1, long jarg2, long jarg3, long jarg4); + + public static final native long bitwuzla_mk_term(int jarg1, long jarg2, long[] jarg3); + + public static final native long bitwuzla_mk_term1_indexed1(int jarg1, long jarg2, long jarg3); + + public static final native long bitwuzla_mk_term1_indexed2( + int jarg1, long jarg2, long jarg3, long jarg4); + + public static final native long bitwuzla_mk_term2_indexed1( + int jarg1, long jarg2, long jarg3, long jarg4); + + public static final native long bitwuzla_mk_term2_indexed2( + int jarg1, long jarg2, long jarg3, long jarg4, long jarg5); + + public static final native long bitwuzla_mk_term_indexed( + int jarg1, long jarg2, long[] jarg3, long jarg4, long[] jarg5); + + public static final native long bitwuzla_mk_const(long jarg1, String jarg2); + + public static final native long bitwuzla_mk_const_array(long jarg1, long jarg2); + + public static final native long bitwuzla_mk_var(long jarg1, String jarg2); + + public static final native long bitwuzla_substitute_term( + long jarg1, long jarg2, long[] jarg3, long[] jarg4); + + public static final native void bitwuzla_substitute_terms( + long sizeOfTermsToSubstituteIn, + long[] termsToSubstituteIn, + long sizeOfSubstitutionMap, + long[] mapKeys, + long[] mapValues); + + public static final native void bitwuzla_parser_delete(long jarg1); + + public static final native String bitwuzla_parser_parse(long jarg1, boolean jarg2); + + public static final native long bitwuzla_parser_get_bitwuzla(long jarg1); + + // This returns the assertions of the input String as formulas individually + public static final native long[] parse(String jarg); + + /** + * Dumps the SMT2 String representation of a entered Bitwuzla term. + * + * @param term Bitwuzla term. + * @param baseOfValueInterpretation base of the values to be printed. I.e. 2, 10 or 16. + * @return String of the term. + */ + public static final native String dump_formula_smt2(long term, int baseOfValueInterpretation); + + /** + * Prints the assertion stack of the entered Bitwuzla environment. + * + * @param env a Bitwuzla environment where the assertion stack should be printed. + * @param baseOfValueInterpretation base of the values to be printed. I.e. 2, 10 or 16. + * @return String of the terms on the assertion stack. + */ + public static final native String dump_assertions_smt2(long env, int baseOfValueInterpretation); + + /** + * Sets termination callback to chosen implementation of a method. + * + * @param env instance + * @param terminationCallback TerminationCallback method + * @return address to helper struct. Call method boolector_free_termination with it to free its + * ressources after termination! + */ + protected static native long set_termination(long env, TerminationCallback terminationCallback); + + /** + * Frees resources of the termination callback function. Call ONLY after termination has occured + * with the return value of set_termination of its instance! + * + * @param helper address to helper struct used in termination callback. + */ + protected static native void free_termination(long helper); + + /** This is used to get the methodID for the JNI call to the termination callback method. */ + interface TerminationCallback { + boolean shouldTerminate() throws InterruptedException; + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaKind.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaKind.java new file mode 100644 index 0000000000..430c46069d --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaKind.java @@ -0,0 +1,314 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +public final class BitwuzlaKind { + // FIXME: We should use SWIG to auto-generate the enum for us. This class will break whenever + // bitwuzla changes their definitions. + + private static int swigNext = 0; + private final int swigValue; + private final String swigName; + public static final BitwuzlaKind BITWUZLA_KIND_CONSTANT = + BitwuzlaKind.of("BITWUZLA_KIND_CONSTANT", BitwuzlaJNI.BITWUZLA_KIND_CONSTANT_get()); + public static final BitwuzlaKind BITWUZLA_KIND_CONST_ARRAY = + BitwuzlaKind.of("BITWUZLA_KIND_CONST_ARRAY"); + public static final BitwuzlaKind BITWUZLA_KIND_VALUE = BitwuzlaKind.of("BITWUZLA_KIND_VALUE"); + public static final BitwuzlaKind BITWUZLA_KIND_VARIABLE = + BitwuzlaKind.of("BITWUZLA_KIND_VARIABLE"); + public static final BitwuzlaKind BITWUZLA_KIND_AND = BitwuzlaKind.of("BITWUZLA_KIND_AND"); + public static final BitwuzlaKind BITWUZLA_KIND_DISTINCT = + BitwuzlaKind.of("BITWUZLA_KIND_DISTINCT"); + public static final BitwuzlaKind BITWUZLA_KIND_EQUAL = BitwuzlaKind.of("BITWUZLA_KIND_EQUAL"); + public static final BitwuzlaKind BITWUZLA_KIND_IFF = BitwuzlaKind.of("BITWUZLA_KIND_IFF"); + public static final BitwuzlaKind BITWUZLA_KIND_IMPLIES = BitwuzlaKind.of("BITWUZLA_KIND_IMPLIES"); + public static final BitwuzlaKind BITWUZLA_KIND_NOT = BitwuzlaKind.of("BITWUZLA_KIND_NOT"); + public static final BitwuzlaKind BITWUZLA_KIND_OR = BitwuzlaKind.of("BITWUZLA_KIND_OR"); + public static final BitwuzlaKind BITWUZLA_KIND_XOR = BitwuzlaKind.of("BITWUZLA_KIND_XOR"); + public static final BitwuzlaKind BITWUZLA_KIND_ITE = BitwuzlaKind.of("BITWUZLA_KIND_ITE"); + public static final BitwuzlaKind BITWUZLA_KIND_EXISTS = BitwuzlaKind.of("BITWUZLA_KIND_EXISTS"); + public static final BitwuzlaKind BITWUZLA_KIND_FORALL = BitwuzlaKind.of("BITWUZLA_KIND_FORALL"); + public static final BitwuzlaKind BITWUZLA_KIND_APPLY = BitwuzlaKind.of("BITWUZLA_KIND_APPLY"); + public static final BitwuzlaKind BITWUZLA_KIND_LAMBDA = BitwuzlaKind.of("BITWUZLA_KIND_LAMBDA"); + public static final BitwuzlaKind BITWUZLA_KIND_ARRAY_SELECT = + BitwuzlaKind.of("BITWUZLA_KIND_ARRAY_SELECT"); + public static final BitwuzlaKind BITWUZLA_KIND_ARRAY_STORE = + BitwuzlaKind.of("BITWUZLA_KIND_ARRAY_STORE"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_ADD = BitwuzlaKind.of("BITWUZLA_KIND_BV_ADD"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_AND = BitwuzlaKind.of("BITWUZLA_KIND_BV_AND"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_ASHR = BitwuzlaKind.of("BITWUZLA_KIND_BV_ASHR"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_COMP = BitwuzlaKind.of("BITWUZLA_KIND_BV_COMP"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_CONCAT = + BitwuzlaKind.of("BITWUZLA_KIND_BV_CONCAT"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_DEC = BitwuzlaKind.of("BITWUZLA_KIND_BV_DEC"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_INC = BitwuzlaKind.of("BITWUZLA_KIND_BV_INC"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_MUL = BitwuzlaKind.of("BITWUZLA_KIND_BV_MUL"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_NAND = BitwuzlaKind.of("BITWUZLA_KIND_BV_NAND"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_NEG = BitwuzlaKind.of("BITWUZLA_KIND_BV_NEG"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_NEG_OVERFLOW = + BitwuzlaKind.of("BITWUZLA_KIND_BV_NEG_OVERFLOW"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_NOR = BitwuzlaKind.of("BITWUZLA_KIND_BV_NOR"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_NOT = BitwuzlaKind.of("BITWUZLA_KIND_BV_NOT"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_OR = BitwuzlaKind.of("BITWUZLA_KIND_BV_OR"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_REDAND = + BitwuzlaKind.of("BITWUZLA_KIND_BV_REDAND"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_REDOR = + BitwuzlaKind.of("BITWUZLA_KIND_BV_REDOR"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_REDXOR = + BitwuzlaKind.of("BITWUZLA_KIND_BV_REDXOR"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_ROL = BitwuzlaKind.of("BITWUZLA_KIND_BV_ROL"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_ROR = BitwuzlaKind.of("BITWUZLA_KIND_BV_ROR"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SADD_OVERFLOW = + BitwuzlaKind.of("BITWUZLA_KIND_BV_SADD_OVERFLOW"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SDIV_OVERFLOW = + BitwuzlaKind.of("BITWUZLA_KIND_BV_SDIV_OVERFLOW"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SDIV = BitwuzlaKind.of("BITWUZLA_KIND_BV_SDIV"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SGE = BitwuzlaKind.of("BITWUZLA_KIND_BV_SGE"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SGT = BitwuzlaKind.of("BITWUZLA_KIND_BV_SGT"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SHL = BitwuzlaKind.of("BITWUZLA_KIND_BV_SHL"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SHR = BitwuzlaKind.of("BITWUZLA_KIND_BV_SHR"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SLE = BitwuzlaKind.of("BITWUZLA_KIND_BV_SLE"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SLT = BitwuzlaKind.of("BITWUZLA_KIND_BV_SLT"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SMOD = BitwuzlaKind.of("BITWUZLA_KIND_BV_SMOD"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SMUL_OVERFLOW = + BitwuzlaKind.of("BITWUZLA_KIND_BV_SMUL_OVERFLOW"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SREM = BitwuzlaKind.of("BITWUZLA_KIND_BV_SREM"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SSUB_OVERFLOW = + BitwuzlaKind.of("BITWUZLA_KIND_BV_SSUB_OVERFLOW"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SUB = BitwuzlaKind.of("BITWUZLA_KIND_BV_SUB"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_UADD_OVERFLOW = + BitwuzlaKind.of("BITWUZLA_KIND_BV_UADD_OVERFLOW"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_UDIV = BitwuzlaKind.of("BITWUZLA_KIND_BV_UDIV"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_UGE = BitwuzlaKind.of("BITWUZLA_KIND_BV_UGE"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_UGT = BitwuzlaKind.of("BITWUZLA_KIND_BV_UGT"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_ULE = BitwuzlaKind.of("BITWUZLA_KIND_BV_ULE"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_ULT = BitwuzlaKind.of("BITWUZLA_KIND_BV_ULT"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_UMUL_OVERFLOW = + BitwuzlaKind.of("BITWUZLA_KIND_BV_UMUL_OVERFLOW"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_UREM = BitwuzlaKind.of("BITWUZLA_KIND_BV_UREM"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_USUB_OVERFLOW = + BitwuzlaKind.of("BITWUZLA_KIND_BV_USUB_OVERFLOW"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_XNOR = BitwuzlaKind.of("BITWUZLA_KIND_BV_XNOR"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_XOR = BitwuzlaKind.of("BITWUZLA_KIND_BV_XOR"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_EXTRACT = + BitwuzlaKind.of("BITWUZLA_KIND_BV_EXTRACT"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_REPEAT = + BitwuzlaKind.of("BITWUZLA_KIND_BV_REPEAT"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_ROLI = BitwuzlaKind.of("BITWUZLA_KIND_BV_ROLI"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_RORI = BitwuzlaKind.of("BITWUZLA_KIND_BV_RORI"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_SIGN_EXTEND = + BitwuzlaKind.of("BITWUZLA_KIND_BV_SIGN_EXTEND"); + public static final BitwuzlaKind BITWUZLA_KIND_BV_ZERO_EXTEND = + BitwuzlaKind.of("BITWUZLA_KIND_BV_ZERO_EXTEND"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_ABS = BitwuzlaKind.of("BITWUZLA_KIND_FP_ABS"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_ADD = BitwuzlaKind.of("BITWUZLA_KIND_FP_ADD"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_DIV = BitwuzlaKind.of("BITWUZLA_KIND_FP_DIV"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_EQUAL = + BitwuzlaKind.of("BITWUZLA_KIND_FP_EQUAL"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_FMA = BitwuzlaKind.of("BITWUZLA_KIND_FP_FMA"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_FP = BitwuzlaKind.of("BITWUZLA_KIND_FP_FP"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_GEQ = BitwuzlaKind.of("BITWUZLA_KIND_FP_GEQ"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_GT = BitwuzlaKind.of("BITWUZLA_KIND_FP_GT"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_IS_INF = + BitwuzlaKind.of("BITWUZLA_KIND_FP_IS_INF"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_IS_NAN = + BitwuzlaKind.of("BITWUZLA_KIND_FP_IS_NAN"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_IS_NEG = + BitwuzlaKind.of("BITWUZLA_KIND_FP_IS_NEG"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_IS_NORMAL = + BitwuzlaKind.of("BITWUZLA_KIND_FP_IS_NORMAL"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_IS_POS = + BitwuzlaKind.of("BITWUZLA_KIND_FP_IS_POS"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_IS_SUBNORMAL = + BitwuzlaKind.of("BITWUZLA_KIND_FP_IS_SUBNORMAL"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_IS_ZERO = + BitwuzlaKind.of("BITWUZLA_KIND_FP_IS_ZERO"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_LEQ = BitwuzlaKind.of("BITWUZLA_KIND_FP_LEQ"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_LT = BitwuzlaKind.of("BITWUZLA_KIND_FP_LT"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_MAX = BitwuzlaKind.of("BITWUZLA_KIND_FP_MAX"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_MIN = BitwuzlaKind.of("BITWUZLA_KIND_FP_MIN"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_MUL = BitwuzlaKind.of("BITWUZLA_KIND_FP_MUL"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_NEG = BitwuzlaKind.of("BITWUZLA_KIND_FP_NEG"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_REM = BitwuzlaKind.of("BITWUZLA_KIND_FP_REM"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_RTI = BitwuzlaKind.of("BITWUZLA_KIND_FP_RTI"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_SQRT = BitwuzlaKind.of("BITWUZLA_KIND_FP_SQRT"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_SUB = BitwuzlaKind.of("BITWUZLA_KIND_FP_SUB"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_TO_FP_FROM_BV = + BitwuzlaKind.of("BITWUZLA_KIND_FP_TO_FP_FROM_BV"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_TO_FP_FROM_FP = + BitwuzlaKind.of("BITWUZLA_KIND_FP_TO_FP_FROM_FP"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_TO_FP_FROM_SBV = + BitwuzlaKind.of("BITWUZLA_KIND_FP_TO_FP_FROM_SBV"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_TO_FP_FROM_UBV = + BitwuzlaKind.of("BITWUZLA_KIND_FP_TO_FP_FROM_UBV"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_TO_SBV = + BitwuzlaKind.of("BITWUZLA_KIND_FP_TO_SBV"); + public static final BitwuzlaKind BITWUZLA_KIND_FP_TO_UBV = + BitwuzlaKind.of("BITWUZLA_KIND_FP_TO_UBV"); + public static final BitwuzlaKind BITWUZLA_KIND_NUM_KINDS = + BitwuzlaKind.of("BITWUZLA_KIND_NUM_KINDS"); + + public int swigValue() { + return swigValue; + } + + @Override + public String toString() { + return swigName; + } + + public static BitwuzlaKind swigToEnum(int swigValue) { + if (swigValue < swigValues.length + && swigValue >= 0 + && swigValues[swigValue].swigValue == swigValue) { + return swigValues[swigValue]; + } + for (int i = 0; i < swigValues.length; i++) { + if (swigValues[i].swigValue == swigValue) { + return swigValues[i]; + } + } + throw new IllegalArgumentException( + "No enum " + BitwuzlaKind.class + " with value " + swigValue); + } + + private BitwuzlaKind(String swigName) { + this.swigName = swigName; + this.swigValue = BitwuzlaKind.swigNext; + } + + private static BitwuzlaKind of(String swigName) { + BitwuzlaKind kind = new BitwuzlaKind(swigName); + BitwuzlaKind.swigNext++; + return kind; + } + + private BitwuzlaKind(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + } + + private static BitwuzlaKind of(String swigName, int swigValue) { + BitwuzlaKind kind = new BitwuzlaKind(swigName, swigValue); + BitwuzlaKind.swigNext = swigValue + 1; + return kind; + } + + private static BitwuzlaKind[] swigValues = { + BITWUZLA_KIND_CONSTANT, + BITWUZLA_KIND_CONST_ARRAY, + BITWUZLA_KIND_VALUE, + BITWUZLA_KIND_VARIABLE, + BITWUZLA_KIND_AND, + BITWUZLA_KIND_DISTINCT, + BITWUZLA_KIND_EQUAL, + BITWUZLA_KIND_IFF, + BITWUZLA_KIND_IMPLIES, + BITWUZLA_KIND_NOT, + BITWUZLA_KIND_OR, + BITWUZLA_KIND_XOR, + BITWUZLA_KIND_ITE, + BITWUZLA_KIND_EXISTS, + BITWUZLA_KIND_FORALL, + BITWUZLA_KIND_APPLY, + BITWUZLA_KIND_LAMBDA, + BITWUZLA_KIND_ARRAY_SELECT, + BITWUZLA_KIND_ARRAY_STORE, + BITWUZLA_KIND_BV_ADD, + BITWUZLA_KIND_BV_AND, + BITWUZLA_KIND_BV_ASHR, + BITWUZLA_KIND_BV_COMP, + BITWUZLA_KIND_BV_CONCAT, + BITWUZLA_KIND_BV_DEC, + BITWUZLA_KIND_BV_INC, + BITWUZLA_KIND_BV_MUL, + BITWUZLA_KIND_BV_NAND, + BITWUZLA_KIND_BV_NEG, + BITWUZLA_KIND_BV_NEG_OVERFLOW, + BITWUZLA_KIND_BV_NOR, + BITWUZLA_KIND_BV_NOT, + BITWUZLA_KIND_BV_OR, + BITWUZLA_KIND_BV_REDAND, + BITWUZLA_KIND_BV_REDOR, + BITWUZLA_KIND_BV_REDXOR, + BITWUZLA_KIND_BV_ROL, + BITWUZLA_KIND_BV_ROR, + BITWUZLA_KIND_BV_SADD_OVERFLOW, + BITWUZLA_KIND_BV_SDIV_OVERFLOW, + BITWUZLA_KIND_BV_SDIV, + BITWUZLA_KIND_BV_SGE, + BITWUZLA_KIND_BV_SGT, + BITWUZLA_KIND_BV_SHL, + BITWUZLA_KIND_BV_SHR, + BITWUZLA_KIND_BV_SLE, + BITWUZLA_KIND_BV_SLT, + BITWUZLA_KIND_BV_SMOD, + BITWUZLA_KIND_BV_SMUL_OVERFLOW, + BITWUZLA_KIND_BV_SREM, + BITWUZLA_KIND_BV_SSUB_OVERFLOW, + BITWUZLA_KIND_BV_SUB, + BITWUZLA_KIND_BV_UADD_OVERFLOW, + BITWUZLA_KIND_BV_UDIV, + BITWUZLA_KIND_BV_UGE, + BITWUZLA_KIND_BV_UGT, + BITWUZLA_KIND_BV_ULE, + BITWUZLA_KIND_BV_ULT, + BITWUZLA_KIND_BV_UMUL_OVERFLOW, + BITWUZLA_KIND_BV_UREM, + BITWUZLA_KIND_BV_USUB_OVERFLOW, + BITWUZLA_KIND_BV_XNOR, + BITWUZLA_KIND_BV_XOR, + BITWUZLA_KIND_BV_EXTRACT, + BITWUZLA_KIND_BV_REPEAT, + BITWUZLA_KIND_BV_ROLI, + BITWUZLA_KIND_BV_RORI, + BITWUZLA_KIND_BV_SIGN_EXTEND, + BITWUZLA_KIND_BV_ZERO_EXTEND, + BITWUZLA_KIND_FP_ABS, + BITWUZLA_KIND_FP_ADD, + BITWUZLA_KIND_FP_DIV, + BITWUZLA_KIND_FP_EQUAL, + BITWUZLA_KIND_FP_FMA, + BITWUZLA_KIND_FP_FP, + BITWUZLA_KIND_FP_GEQ, + BITWUZLA_KIND_FP_GT, + BITWUZLA_KIND_FP_IS_INF, + BITWUZLA_KIND_FP_IS_NAN, + BITWUZLA_KIND_FP_IS_NEG, + BITWUZLA_KIND_FP_IS_NORMAL, + BITWUZLA_KIND_FP_IS_POS, + BITWUZLA_KIND_FP_IS_SUBNORMAL, + BITWUZLA_KIND_FP_IS_ZERO, + BITWUZLA_KIND_FP_LEQ, + BITWUZLA_KIND_FP_LT, + BITWUZLA_KIND_FP_MAX, + BITWUZLA_KIND_FP_MIN, + BITWUZLA_KIND_FP_MUL, + BITWUZLA_KIND_FP_NEG, + BITWUZLA_KIND_FP_REM, + BITWUZLA_KIND_FP_RTI, + BITWUZLA_KIND_FP_SQRT, + BITWUZLA_KIND_FP_SUB, + BITWUZLA_KIND_FP_TO_FP_FROM_BV, + BITWUZLA_KIND_FP_TO_FP_FROM_FP, + BITWUZLA_KIND_FP_TO_FP_FROM_SBV, + BITWUZLA_KIND_FP_TO_FP_FROM_UBV, + BITWUZLA_KIND_FP_TO_SBV, + BITWUZLA_KIND_FP_TO_UBV, + BITWUZLA_KIND_NUM_KINDS, + }; +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaModel.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaModel.java new file mode 100644 index 0000000000..d9ea7d77d0 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaModel.java @@ -0,0 +1,238 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Deque; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import org.checkerframework.checker.nullness.qual.Nullable; +import org.sosy_lab.java_smt.basicimpl.AbstractModel; + +class BitwuzlaModel extends AbstractModel { + + // The prover env, not the creator env! + private final long bitwuzlaEnv; + + private final BitwuzlaTheoremProver prover; + + private final BitwuzlaFormulaCreator bitwuzlaCreator; + private final ImmutableList assertedTerms; + + protected BitwuzlaModel( + long bitwuzlaEnv, + BitwuzlaTheoremProver prover, + BitwuzlaFormulaCreator bitwuzlaCreator, + Collection assertedTerms) { + super(prover, bitwuzlaCreator); + this.bitwuzlaEnv = bitwuzlaEnv; + this.prover = prover; + this.bitwuzlaCreator = bitwuzlaCreator; + this.assertedTerms = ImmutableList.copyOf(assertedTerms); + } + + /** Build a list of assignments that stays valid after closing the model. */ + @Override + public ImmutableList asList() { + Preconditions.checkState(!isClosed()); + Preconditions.checkState(!prover.isClosed(), "Cannot use model after prover is closed"); + ImmutableSet.Builder variablesBuilder = ImmutableSet.builder(); + Deque queue = new ArrayDeque<>(assertedTerms); + while (!queue.isEmpty()) { + long term = queue.removeFirst(); + long[] children = BitwuzlaJNI.bitwuzla_term_get_children(term, new long[1]); + // The term might be a value (variable or const, w only variable having a symbol) + // an array, an UF, or an FP or a function. + // Functions are just split into their children and those are traversed + if (BitwuzlaJNI.bitwuzla_term_is_rm(term)) { + // Do nothing + } else if (BitwuzlaJNI.bitwuzla_term_get_kind(term) + == BitwuzlaKind.BITWUZLA_KIND_APPLY.swigValue()) { + variablesBuilder.add(getUFAssignment(term)); + for (int i = 1; i < children.length; i++) { + queue.addLast(children[i]); + } + + } else if (BitwuzlaJNI.bitwuzla_term_is_bv(term) + && BitwuzlaJNI.bitwuzla_term_is_const(term)) { + variablesBuilder.add(getSimpleAssignment(term)); + + } else if (BitwuzlaJNI.bitwuzla_term_is_bool(term) + && BitwuzlaJNI.bitwuzla_term_is_const(term)) { + variablesBuilder.add(getSimpleAssignment(term)); + + } else if (BitwuzlaJNI.bitwuzla_term_is_fp(term) + && BitwuzlaJNI.bitwuzla_term_is_const(term)) { + // We can't eval FP properly at the moment, we just return whatever the solver gives us + // (BV representation of the FP) + variablesBuilder.add(getSimpleAssignment(term)); + + } else if (BitwuzlaJNI.bitwuzla_term_is_array(term) + && BitwuzlaJNI.bitwuzla_term_is_const(term)) { + variablesBuilder.addAll(getArrayAssignment(term)); + + } else { + for (long child : children) { + queue.addLast(child); + } + } + } + + return variablesBuilder.build().asList(); + } + + private ValueAssignment getSimpleAssignment(long pTerm) { + List argumentInterpretation = new ArrayList<>(); + long valueTerm = BitwuzlaJNI.bitwuzla_get_value(bitwuzlaEnv, pTerm); + String name = BitwuzlaJNI.bitwuzla_term_get_symbol(pTerm); + assert name != null; + return new ValueAssignment( + bitwuzlaCreator.encapsulateWithTypeOf(pTerm), + bitwuzlaCreator.encapsulateWithTypeOf(valueTerm), + bitwuzlaCreator.encapsulateBoolean(buildEqForTwoTerms(pTerm, valueTerm)), + name, + bitwuzlaCreator.convertValue(valueTerm), + argumentInterpretation); + } + + private Collection getArrayAssignment(long pTerm) { + return getArrayAssignments(pTerm, ImmutableList.of()); + } + + // TODO: check this in detail. I think this might be incomplete. + // We should add more Model tests in general. As most are parsing and int based! + private Collection getArrayAssignments(long pTerm, List upperIndices) { + // Array children for store are structured in the following way: + // {starting array, index, value} in "we add value at index to array" + // Selections are structured: {starting array, index} + // Just declared (empty) arrays return an empty array + + // Example Formula: (SELECT ARRAY INDEX) + // new ValueAssignment((SELECT ARRAY INDEX), value formula of INDEX, (SELECT ARRAY INDEX) = + // value of index, name of INDEX, actual java value of index, {return java value of the + // formula}) + + // TODO: Array equals value + long array = pTerm; + Collection assignments = new ArrayList<>(); + Set indices = new HashSet<>(); + while (BitwuzlaJNI.bitwuzla_term_is_array(array)) { + // Here we either have STORE; SELECT or an empty Array + long[] children = BitwuzlaJNI.bitwuzla_term_get_children(array, new long[1]); + List innerIndices = new ArrayList<>(upperIndices); + String name = getArrayName(array); + assert name != null; + if (children.length == 0) { + // Empty array + return assignments; + } else if (children.length == 2) { + // SELECT expression + long index = children[1]; + + if (!indices.add(index)) { + continue; + } + + long indexValue = BitwuzlaJNI.bitwuzla_get_value(bitwuzlaEnv, index); + innerIndices.add(evaluateImpl(indexValue)); + + // The value of an SELECT is equal to the content + long valueTerm = BitwuzlaJNI.bitwuzla_get_value(bitwuzlaEnv, array); + + assignments.add( + new ValueAssignment( + bitwuzlaCreator.encapsulateWithTypeOf(array), + bitwuzlaCreator.encapsulateWithTypeOf(valueTerm), + creator.encapsulateBoolean(buildEqForTwoTerms(pTerm, valueTerm)), + name, + evaluateImpl(valueTerm), + innerIndices)); + array = children[0]; + + } else { + // STORE expression + assert children.length == 3; + long index = children[1]; + long content = children[2]; + + if (!indices.add(index)) { + continue; + } + + long indexValue = BitwuzlaJNI.bitwuzla_get_value(bitwuzlaEnv, index); + long contentValue = BitwuzlaJNI.bitwuzla_get_value(bitwuzlaEnv, content); + innerIndices.add(evaluateImpl(indexValue)); + assignments.add( + new ValueAssignment( + bitwuzlaCreator.encapsulateWithTypeOf(array), + bitwuzlaCreator.encapsulateWithTypeOf(content), + creator.encapsulateBoolean(buildEqForTwoTerms(array, contentValue)), + name, + evaluateImpl(contentValue), + innerIndices)); + + array = children[0]; + assignments.addAll(getArrayAssignments(array, innerIndices)); + } + } + return assignments; + } + + private String getArrayName(long array) { + String name = BitwuzlaJNI.bitwuzla_term_get_symbol(array); + if (name != null) { + return name; + } + return getArrayName(BitwuzlaJNI.bitwuzla_term_get_children(array, new long[1])[0]); + } + + private long buildEqForTwoTerms(long left, long right) { + assert BitwuzlaJNI.bitwuzla_term_is_equal_sort(left, right); + BitwuzlaKind kind = BitwuzlaKind.BITWUZLA_KIND_EQUAL; + if (BitwuzlaJNI.bitwuzla_term_is_fp(left)) { + kind = BitwuzlaKind.BITWUZLA_KIND_FP_EQUAL; + } + return BitwuzlaJNI.bitwuzla_mk_term2(kind.swigValue(), left, right); + } + + private ValueAssignment getUFAssignment(long pTerm) { + long valueTerm = BitwuzlaJNI.bitwuzla_get_value(bitwuzlaEnv, pTerm); + // The first child is the decl, the others are args + long[] children = BitwuzlaJNI.bitwuzla_term_get_children(pTerm, new long[1]); + String name = BitwuzlaJNI.bitwuzla_term_get_symbol(children[0]); + assert name != null; + + List argumentInterpretation = new ArrayList<>(); + for (int i = 1; i < children.length; i++) { + long child = children[i]; + long childValue = BitwuzlaJNI.bitwuzla_get_value(bitwuzlaEnv, child); + argumentInterpretation.add(creator.convertValue(childValue)); + } + + return new ValueAssignment( + bitwuzlaCreator.encapsulateWithTypeOf(pTerm), + bitwuzlaCreator.encapsulateWithTypeOf(valueTerm), + bitwuzlaCreator.encapsulateBoolean(buildEqForTwoTerms(pTerm, valueTerm)), + name, + bitwuzlaCreator.convertValue(valueTerm), + argumentInterpretation); + } + + @Override + protected @Nullable Long evalImpl(Long formula) { + Preconditions.checkState(!prover.isClosed(), "Cannot use model after prover is closed"); + return BitwuzlaJNI.bitwuzla_get_value(bitwuzlaEnv, formula); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaNativeApiTest.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaNativeApiTest.java new file mode 100644 index 0000000000..82e0f11d3e --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaNativeApiTest.java @@ -0,0 +1,910 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.truth.Truth; +import org.junit.After; +import org.junit.AssumptionViolatedException; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.sosy_lab.common.NativeLibraries; + +public class BitwuzlaNativeApiTest { + private long bitwuzla; + + @BeforeClass + public static void load() { + try { + NativeLibraries.loadLibrary("bitwuzlaJNI"); + } catch (UnsatisfiedLinkError e) { + throw new AssumptionViolatedException("Bitwuzla is not available", e); + } + } + + @Before + public void createEnvironment() { + long options = BitwuzlaJNI.bitwuzla_options_new(); + BitwuzlaJNI.bitwuzla_set_option( + options, BitwuzlaOption.BITWUZLA_OPT_REWRITE_LEVEL.swigValue(), 0); + BitwuzlaJNI.bitwuzla_set_option( + options, BitwuzlaOption.BITWUZLA_OPT_PRODUCE_MODELS.swigValue(), 1); + // Cadical is always the default solver, but this shows how to set the option + BitwuzlaJNI.bitwuzla_set_option_mode( + options, BitwuzlaOption.BITWUZLA_OPT_SAT_SOLVER.swigValue(), "cadical"); + bitwuzla = BitwuzlaJNI.bitwuzla_new(options); + } + + @After + public void freeEnvironment() { + BitwuzlaJNI.bitwuzla_delete(bitwuzla); + } + + // @Test + // public void functionWithNoArguments() { + // NativeLibraries.loadLibrary("bitwuzlaJNI"); + // long bool_sort = bitwuzlaJNI.bitwuzla_mk_bool_sort(); + // long a = bitwuzlaJNI.bitwuzla_mk_var(bool_sort, "a"); + // + // long noArgumentUF = + // bitwuzlaJNI.bitwuzla_mk_term1( + // BitwuzlaKind.BITWUZLA_KIND_LAMBDA.swigValue(), a); + // } + + @Test + public void unsignedFunctions() { + long sortbv4 = BitwuzlaJNI.bitwuzla_mk_bv_sort(4); + long sortbv8 = BitwuzlaJNI.bitwuzla_mk_bv_sort(8); + // Create function sort. + long[] domain = {sortbv8, sortbv4}; + long sortfun = BitwuzlaJNI.bitwuzla_mk_fun_sort(2, domain, sortbv8); + + long x = BitwuzlaJNI.bitwuzla_mk_const(sortbv8, "x"); + long f = BitwuzlaJNI.bitwuzla_mk_const(sortfun, "f"); + + long term = + BitwuzlaJNI.bitwuzla_mk_term3( + BitwuzlaKind.BITWUZLA_KIND_APPLY.swigValue(), + f, + x, + BitwuzlaJNI.bitwuzla_mk_term1_indexed2( + BitwuzlaKind.BITWUZLA_KIND_BV_EXTRACT.swigValue(), x, 6, 3)); + + long resultSort = BitwuzlaJNI.bitwuzla_term_get_sort(term); + + assertThat(BitwuzlaJNI.bitwuzla_sort_is_equal(sortbv8, resultSort)).isTrue(); + } + + @SuppressWarnings("CheckReturnValue") + @Test + public void quickstartExample() { + // Create bit-vector sorts of size 4 and 8. + long sortbv4 = BitwuzlaJNI.bitwuzla_mk_bv_sort(4); + long sortbv8 = BitwuzlaJNI.bitwuzla_mk_bv_sort(8); + // Create function sort. + long[] domain = {sortbv8, sortbv4}; + long sortfun = BitwuzlaJNI.bitwuzla_mk_fun_sort(2, domain, sortbv8); + // Create array sort. + long sortarr = BitwuzlaJNI.bitwuzla_mk_array_sort(sortbv8, sortbv8); + + // Create two bit-vector constants of that sort. + long x = BitwuzlaJNI.bitwuzla_mk_const(sortbv8, "x"); + long y = BitwuzlaJNI.bitwuzla_mk_const(sortbv8, "y"); + long f = BitwuzlaJNI.bitwuzla_mk_const(sortfun, "f"); + long a = BitwuzlaJNI.bitwuzla_mk_const(sortarr, "a"); + // Create bit-vector values one and two of the same sort. + long one = BitwuzlaJNI.bitwuzla_mk_bv_one(sortbv8); + long two = BitwuzlaJNI.bitwuzla_mk_bv_value_uint64(sortbv8, 2); + + // (bvsdiv x (_ bv2 8)) + long sdiv = + BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_BV_SDIV.swigValue(), x, two); + // (bvashr y (_ bv1 8)) + long ashr = + BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_BV_ASHR.swigValue(), y, one); + // ((_ extract 3 0) (bvsdiv x (_ bv2 8))) + long sdive = + BitwuzlaJNI.bitwuzla_mk_term1_indexed2( + BitwuzlaKind.BITWUZLA_KIND_BV_EXTRACT.swigValue(), sdiv, 3, 0); + // ((_ extract 3 0) (bvashr x (_ bv1 8))) + long ashre = + BitwuzlaJNI.bitwuzla_mk_term1_indexed2( + BitwuzlaKind.BITWUZLA_KIND_BV_EXTRACT.swigValue(), ashr, 3, 0); + + // (assert + // (distinct + // ((_ extract 3 0) (bvsdiv x (_ bv2 8))) + // ((_ extract 3 0) (bvashr y (_ bv1 8))))) + BitwuzlaJNI.bitwuzla_assert( + bitwuzla, + BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_DISTINCT.swigValue(), sdive, ashre)); + + // (assert (= (f x ((_ extract 6 3) x)) y)) + BitwuzlaJNI.bitwuzla_assert( + bitwuzla, + BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), + BitwuzlaJNI.bitwuzla_mk_term3( + BitwuzlaKind.BITWUZLA_KIND_APPLY.swigValue(), + f, + x, + BitwuzlaJNI.bitwuzla_mk_term1_indexed2( + BitwuzlaKind.BITWUZLA_KIND_BV_EXTRACT.swigValue(), x, 6, 3)), + y)); + + // (assert (= (select a x) y)) + BitwuzlaJNI.bitwuzla_assert( + bitwuzla, + BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), + BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_ARRAY_SELECT.swigValue(), a, x), + y)); + + // (check-sat) + long result = BitwuzlaJNI.bitwuzla_check_sat(bitwuzla); + assertThat(result).isEqualTo(BitwuzlaResult.BITWUZLA_SAT.swigValue()); + + // Print model in SMT-LIBv2 format. + // We call the API to check that the calls work, but don't assert them + long[] decls = {x, y, f, a}; + + // System.out.println("("); + for (int i = 0; i < 4; ++i) { + long sort = BitwuzlaJNI.bitwuzla_term_get_sort(decls[i]); + // System.out.print(" (define-fun " + BitwuzlaJNI.bitwuzla_term_get_symbol(decls[i]) + " ("); + BitwuzlaJNI.bitwuzla_term_get_symbol(decls[i]); + if (BitwuzlaJNI.bitwuzla_sort_is_fun(sort)) { + long value = BitwuzlaJNI.bitwuzla_get_value(bitwuzla, decls[i]); + long[] size = new long[1]; + long[] children = BitwuzlaJNI.bitwuzla_term_get_children(value, size); + assertThat(size[0]).isEqualTo(2); + // int j = 0; + while (BitwuzlaJNI.bitwuzla_term_get_kind(children[1]) + == BitwuzlaKind.BITWUZLA_KIND_LAMBDA.swigValue()) { + assertThat(BitwuzlaJNI.bitwuzla_term_is_var(children[0])).isTrue(); + BitwuzlaJNI.bitwuzla_term_to_string(children[0]); + BitwuzlaJNI.bitwuzla_sort_to_string(BitwuzlaJNI.bitwuzla_term_get_sort(children[0])); + /*System.out.print( + (j > 0 ? " " : "") + + BitwuzlaJNI.bitwuzla_term_to_string(children[0]) + + " " + + BitwuzlaJNI.bitwuzla_sort_to_string( + BitwuzlaJNI.bitwuzla_term_get_sort(children[0])) + + " ");*/ + value = children[1]; + children = BitwuzlaJNI.bitwuzla_term_get_children(value, size); + // j += 1; + } + assertThat(BitwuzlaJNI.bitwuzla_term_is_var(children[0])).isTrue(); + BitwuzlaJNI.bitwuzla_term_to_string(children[0]); + BitwuzlaJNI.bitwuzla_sort_to_string(BitwuzlaJNI.bitwuzla_term_get_sort(children[0])); + /* + System.out.print( + (j > 0 ? " " : "") + + BitwuzlaJNI.bitwuzla_term_to_string(children[0]) + + " " + + BitwuzlaJNI.bitwuzla_sort_to_string( + BitwuzlaJNI.bitwuzla_term_get_sort(children[0])) + + ") ");*/ + BitwuzlaJNI.bitwuzla_sort_to_string(BitwuzlaJNI.bitwuzla_sort_fun_get_codomain(sort)); + /* + System.out.print( + BitwuzlaJNI.bitwuzla_sort_to_string(BitwuzlaJNI.bitwuzla_sort_fun_get_codomain(sort)) + + " ");*/ + BitwuzlaJNI.bitwuzla_term_to_string(children[1]); + /* + System.out.println(BitwuzlaJNI.bitwuzla_term_to_string(children[1]));*/ + } else { + BitwuzlaJNI.bitwuzla_sort_to_string(sort); + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, decls[i])); + /* + System.out.println( + ") " + + BitwuzlaJNI.bitwuzla_sort_to_string(sort) + + " " + + BitwuzlaJNI.bitwuzla_term_to_string( + BitwuzlaJNI.bitwuzla_get_value(bitwuzla, decls[i])));*/ + } + } + // System.out.println(")"); + + // Print value for x, y, f and a. + // Note: The returned string of bitwuzlaJNI.bitwuzla_term_value_get_str is only valid + // until the next call to bitwuzlaJNI.bitwuzla_term_value_get_str + // Both x and y are bit-vector terms and their value is a bit-vector + // value that can be printed via bitwuzlaJNI.bitwuzla_term_value_get_str(). + BitwuzlaJNI.bitwuzla_term_value_get_str(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, x)); + BitwuzlaJNI.bitwuzla_term_value_get_str(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, y)); + /* + System.out.println( + "value of x: " + + BitwuzlaJNI.bitwuzla_term_value_get_str(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, x))); + System.out.println( + "value of y: " + + BitwuzlaJNI.bitwuzla_term_value_get_str(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, y))); + */ + + // f and a, on the other hand, are a function and array term, respectively. + // The value of these terms is not a value term: for f, it is a lambda term, + // and the value of a is represented as a store term. Thus we cannot use + // bitwuzlaJNI.bitwuzla_term_value_get_str(), but we can print the value of the terms + // via bitwuzlaJNI.bitwuzla_term_to_string(). + // System.out.println("to_string representation of value of f:"); + + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, f)); + /* + System.out.println( + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, f)));*/ + // System.out.println("to_string representation of value of a:"); + + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, a)); + /* + System.out.println( + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, a)));*/ + + // Note that the assignment string of bit-vector terms is given as the + // pure assignment string, either in binary, hexadecimal or decimal format, + // whereas bitwuzlaJNI.bitwuzla_term_to_string() prints the value in SMT-LIB2 format + // (in binary number format). + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, x)); + /* + System.out.println( + "to_string representation of value of x: " + + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, x)));*/ + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, y)); + /* + System.out.println( + "to_string representation of value of y: " + + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, y)));*/ + + // Query value of bit-vector term that does not occur in the input formula + long v = + BitwuzlaJNI.bitwuzla_get_value( + bitwuzla, + BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_BV_MUL.swigValue(), x, x)); + /* + System.out.println( + "value of v = x * x: " + + BitwuzlaJNI.bitwuzla_term_value_get_str(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, v))); + */ + BitwuzlaJNI.bitwuzla_term_value_get_str(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, v)); + } + + @Test + public void boolType() { + long pBoolType = BitwuzlaJNI.bitwuzla_mk_bool_sort(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_bool(pBoolType)).isTrue(); + } + + // Bitwuzla fails this critically! + @Ignore + @Test + public void repeatedTermCreationInMultipleSolversTest() { + long tru1 = BitwuzlaJNI.bitwuzla_mk_true(); + long tru12 = BitwuzlaJNI.bitwuzla_mk_true(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_true(tru1)).isTrue(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_true(tru12)).isTrue(); + + new Thread( + () -> { + assertThat(BitwuzlaJNI.bitwuzla_term_is_true(tru1)).isTrue(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_true(tru12)).isTrue(); + }) + .start(); + } + + @Test + public void isFalse() { + long pBoolType = BitwuzlaJNI.bitwuzla_mk_bool_sort(); + long var1 = BitwuzlaJNI.bitwuzla_mk_const(pBoolType, "var1"); + long var2 = BitwuzlaJNI.bitwuzla_mk_const(pBoolType, "var2"); + + Truth.assertThat(BitwuzlaJNI.bitwuzla_term_is_false(var1)).isFalse(); + Truth.assertThat(BitwuzlaJNI.bitwuzla_term_is_true(var1)).isFalse(); + Truth.assertThat(BitwuzlaJNI.bitwuzla_term_is_false(var2)).isFalse(); + Truth.assertThat(BitwuzlaJNI.bitwuzla_term_is_true(var2)).isFalse(); + } + + @Test + public void testBvModel() { + long bvSort = BitwuzlaJNI.bitwuzla_mk_bv_sort(32); + long a = BitwuzlaJNI.bitwuzla_mk_const(bvSort, "a"); + long one = BitwuzlaJNI.bitwuzla_mk_bv_one(bvSort); + long two = BitwuzlaJNI.bitwuzla_mk_bv_value_uint64(bvSort, 2); + + // 1 + 2 = a + long add = + BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_BV_ADD.swigValue(), one, two); + long eq = BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), add, a); + + BitwuzlaJNI.bitwuzla_assert(bitwuzla, eq); + long res = BitwuzlaJNI.bitwuzla_check_sat(bitwuzla); + assertThat(res).isEqualTo(BitwuzlaResult.BITWUZLA_SAT.swigValue()); + + // Get model value as String + String aString = BitwuzlaJNI.bitwuzla_term_to_string(a); + assertThat(aString).isEqualTo("a"); + String aValue = + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, a)); + // #b00000000000000000000000000000011 == 3 + assertThat(aValue).isEqualTo("#b00000000000000000000000000000011"); + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(one)) + .isEqualTo("#b00000000000000000000000000000001"); + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(two)) + .isEqualTo("#b00000000000000000000000000000010"); + } + + @Test + public void testBvArrayModelStore() { + long bvSort4 = BitwuzlaJNI.bitwuzla_mk_bv_sort(4); + long bvSort8 = BitwuzlaJNI.bitwuzla_mk_bv_sort(8); + long sortArr = BitwuzlaJNI.bitwuzla_mk_array_sort(bvSort4, bvSort8); + + long var = BitwuzlaJNI.bitwuzla_mk_const(bvSort8, "var"); + long eleven = BitwuzlaJNI.bitwuzla_mk_bv_value_uint64(bvSort8, 11); + long zero = BitwuzlaJNI.bitwuzla_mk_bv_zero(bvSort4); + long one = BitwuzlaJNI.bitwuzla_mk_bv_one(bvSort4); + + long arr = BitwuzlaJNI.bitwuzla_mk_const(sortArr, "arr"); + + // Array arr = {11, var} AND arr[0] == arr[1] -> var == 11 + long arrW11At0 = + BitwuzlaJNI.bitwuzla_mk_term3( + BitwuzlaKind.BITWUZLA_KIND_ARRAY_STORE.swigValue(), arr, zero, eleven); + long arrWVarAt1 = + BitwuzlaJNI.bitwuzla_mk_term3( + BitwuzlaKind.BITWUZLA_KIND_ARRAY_STORE.swigValue(), arrW11At0, one, var); + long eq = + BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), + BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_ARRAY_SELECT.swigValue(), arrWVarAt1, one), + BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_ARRAY_SELECT.swigValue(), arrWVarAt1, zero)); + + BitwuzlaJNI.bitwuzla_assert(bitwuzla, eq); + long res = BitwuzlaJNI.bitwuzla_check_sat(bitwuzla); + assertThat(res).isEqualTo(BitwuzlaResult.BITWUZLA_SAT.swigValue()); + + // Get model value as String + String varString = BitwuzlaJNI.bitwuzla_term_to_string(var); + assertThat(varString).isEqualTo("var"); + String varValue = + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, var)); + + assertThat(varValue).isEqualTo("#b00001011"); + assertThat( + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, eleven))) + .isEqualTo(varValue); + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(one)).isEqualTo("#b0001"); + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(zero)).isEqualTo("#b0000"); + + assertThat(BitwuzlaJNI.bitwuzla_term_is_array(arrWVarAt1)).isTrue(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_array(arr)).isTrue(); + + // Getting the model of the array prints the SMTLIB2 representation + long valueArrWVarAt1 = BitwuzlaJNI.bitwuzla_get_value(bitwuzla, arrWVarAt1); + // The value of an STORE expression is not really helpful, see string below + String arrWVarAt1ValueString = BitwuzlaJNI.bitwuzla_term_to_string(valueArrWVarAt1); + assertThat(arrWVarAt1ValueString) + .isEqualTo( + "(store (store ((as const (Array (_ BitVec 4) (_ BitVec 8))) #b00000000) #b0000" + + " #b00001011) #b0001 #b00001011)"); + + // We can access the children of the arrays + long[] sizeArr = new long[1]; + // Array children are structured in the following way: + // {starting array, index, value} in "we add value at index to array" + // Just declared (empty) arrays return an empty array + long[] children = BitwuzlaJNI.bitwuzla_term_get_children(arrWVarAt1, sizeArr); + assertThat(children).hasLength(3); + assertThat(sizeArr[0]).isEqualTo(3); + assertThat(children[0]).isEqualTo(arrW11At0); + assertThat(children[1]).isEqualTo(one); + assertThat(children[2]).isEqualTo(var); + long[] children2 = BitwuzlaJNI.bitwuzla_term_get_children(arrW11At0, sizeArr); + assertThat(children).hasLength(3); + assertThat(sizeArr[0]).isEqualTo(3); + assertThat(children2[0]).isEqualTo(arr); + assertThat(children2[1]).isEqualTo(zero); + assertThat(children2[2]).isEqualTo(eleven); + long[] children3 = BitwuzlaJNI.bitwuzla_term_get_children(arr, sizeArr); + assertThat(children3).isEmpty(); + assertThat(sizeArr[0]).isEqualTo(0); + } + + @Test + public void testBvArrayModelSelect() { + long bvSort4 = BitwuzlaJNI.bitwuzla_mk_bv_sort(4); + long bvSort8 = BitwuzlaJNI.bitwuzla_mk_bv_sort(8); + long sortArr = BitwuzlaJNI.bitwuzla_mk_array_sort(bvSort4, bvSort8); + + long eleven = BitwuzlaJNI.bitwuzla_mk_bv_value_uint64(bvSort8, 11); + long zero = BitwuzlaJNI.bitwuzla_mk_bv_zero(bvSort4); + long one = BitwuzlaJNI.bitwuzla_mk_bv_one(bvSort4); + + long arr = BitwuzlaJNI.bitwuzla_mk_const(sortArr, "arr"); + + // Array arr[0] == (store arr[1] 11))[1] + long selectArrAtZero = + BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_ARRAY_SELECT.swigValue(), arr, zero); + long arrWElevenAt1 = + BitwuzlaJNI.bitwuzla_mk_term3( + BitwuzlaKind.BITWUZLA_KIND_ARRAY_STORE.swigValue(), arr, one, eleven); + long selectArrWElevenAtOne = + BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_ARRAY_SELECT.swigValue(), arrWElevenAt1, one); + long eq = + BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), selectArrAtZero, selectArrWElevenAtOne); + + BitwuzlaJNI.bitwuzla_assert(bitwuzla, eq); + long res = BitwuzlaJNI.bitwuzla_check_sat(bitwuzla); + assertThat(res).isEqualTo(BitwuzlaResult.BITWUZLA_SAT.swigValue()); + + String arrAtZeroString = BitwuzlaJNI.bitwuzla_term_get_symbol(selectArrAtZero); + assertThat(arrAtZeroString).isNull(); + // Get model value arr[0] as String + String arrAtZeroValueString = + BitwuzlaJNI.bitwuzla_term_value_get_str( + BitwuzlaJNI.bitwuzla_get_value(bitwuzla, selectArrAtZero)); + // 00001011 == 11 + assertThat(arrAtZeroValueString).isEqualTo("00001011"); + + // Arrays w 2 children are structured in the following way: + // {starting array, index} in "we select index from array" + // Just declared (empty) arrays return an empty children array + long[] children = BitwuzlaJNI.bitwuzla_term_get_children(selectArrAtZero, new long[1]); + assertThat(children).hasLength(2); + assertThat(children[0]).isEqualTo(arr); + String arrSymbol = BitwuzlaJNI.bitwuzla_term_get_symbol(children[0]); + assertThat(arrSymbol).isEqualTo("arr"); + assertThat(children[1]).isEqualTo(zero); + } + + @Test + public void testUfModel() { + long boolSort = BitwuzlaJNI.bitwuzla_mk_bool_sort(); + long res = BitwuzlaJNI.bitwuzla_mk_const(boolSort, "res"); + long bvSort8 = BitwuzlaJNI.bitwuzla_mk_bv_sort(8); + long arg1 = BitwuzlaJNI.bitwuzla_mk_const(bvSort8, "arg1"); + long arg2 = BitwuzlaJNI.bitwuzla_mk_bv_value_uint64(bvSort8, 11); + long[] domain = {bvSort8, bvSort8}; + long sortFun = BitwuzlaJNI.bitwuzla_mk_fun_sort(2, domain, boolSort); + + long foo = BitwuzlaJNI.bitwuzla_mk_const(sortFun, "foo"); + long appliedFoo = + BitwuzlaJNI.bitwuzla_mk_term3( + BitwuzlaKind.BITWUZLA_KIND_APPLY.swigValue(), foo, arg1, arg2); + + long eq = + BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), appliedFoo, res); + BitwuzlaJNI.bitwuzla_assert(bitwuzla, eq); + long result = BitwuzlaJNI.bitwuzla_check_sat(bitwuzla); + assertThat(result).isEqualTo(BitwuzlaResult.BITWUZLA_SAT.swigValue()); + + // Get model value as String + String resString = BitwuzlaJNI.bitwuzla_term_to_string(res); + assertThat(resString).isEqualTo("res"); + String resValue = + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, res)); + + // Bitwuzla seems to default to false and zero + assertThat(resValue).isEqualTo("false"); + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, arg1))) + .isEqualTo("#b00000000"); + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(arg2)).isEqualTo("#b00001011"); + + // Children of the UF are ordered the following: + // {function, arguments...} + // Declaration is empty array + long[] sizeArr = new long[1]; + long[] childrenAppliedFoo = BitwuzlaJNI.bitwuzla_term_get_children(appliedFoo, sizeArr); + assertThat(childrenAppliedFoo).hasLength(3); + assertThat(sizeArr[0]).isEqualTo(3); + assertThat(childrenAppliedFoo[0]).isEqualTo(foo); + assertThat(childrenAppliedFoo[1]).isEqualTo(arg1); + assertThat(childrenAppliedFoo[2]).isEqualTo(arg2); + long[] childrenFoo = BitwuzlaJNI.bitwuzla_term_get_children(foo, sizeArr); + assertThat(childrenFoo).isEmpty(); + assertThat(sizeArr[0]).isEqualTo(0); + } + + @Test + public void testBoolModel() { + long boolSort = BitwuzlaJNI.bitwuzla_mk_bool_sort(); + long x = BitwuzlaJNI.bitwuzla_mk_const(boolSort, "x"); + long t = BitwuzlaJNI.bitwuzla_mk_true(); + long f = BitwuzlaJNI.bitwuzla_mk_false(); + + // (x AND true) OR false + long and = BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_AND.swigValue(), x, t); + long or = BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_OR.swigValue(), and, f); + + BitwuzlaJNI.bitwuzla_assert(bitwuzla, or); + long res = BitwuzlaJNI.bitwuzla_check_sat(bitwuzla); + assertThat(res).isEqualTo(BitwuzlaResult.BITWUZLA_SAT.swigValue()); + + // Get model value as String + String xString = BitwuzlaJNI.bitwuzla_term_to_string(x); + assertThat(xString).isEqualTo("x"); + String xValue = + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, x)); + + assertThat(xValue).isEqualTo("true"); + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(t)).isEqualTo("true"); + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(f)).isEqualTo("false"); + + // Children of AND and OR + long[] sizeArr = new long[1]; + long[] childrenOr = BitwuzlaJNI.bitwuzla_term_get_children(or, sizeArr); + assertThat(childrenOr).hasLength(2); + assertThat(sizeArr[0]).isEqualTo(2); + assertThat(childrenOr[0]).isEqualTo(and); + assertThat(childrenOr[1]).isEqualTo(f); + + assertThat(BitwuzlaJNI.bitwuzla_term_get_kind(or)) + .isEqualTo(BitwuzlaKind.BITWUZLA_KIND_OR.swigValue()); + + long[] childrenAnd = BitwuzlaJNI.bitwuzla_term_get_children(and, sizeArr); + assertThat(childrenOr).hasLength(2); + assertThat(sizeArr[0]).isEqualTo(2); + assertThat(childrenAnd[0]).isEqualTo(x); + assertThat(childrenAnd[1]).isEqualTo(t); + + assertThat(BitwuzlaJNI.bitwuzla_term_get_kind(and)) + .isEqualTo(BitwuzlaKind.BITWUZLA_KIND_AND.swigValue()); + } + + @Test + public void testFpModel() { + long fpSort = BitwuzlaJNI.bitwuzla_mk_fp_sort(5, 11); + long rm = BitwuzlaJNI.bitwuzla_mk_rm_value(BitwuzlaJNI.BITWUZLA_RM_RNE_get()); + long a = BitwuzlaJNI.bitwuzla_mk_const(fpSort, "a"); + long one = BitwuzlaJNI.bitwuzla_mk_fp_from_real(fpSort, rm, "1"); + // Rational with 0 (or only 0s) as the second argument crashes Bitwuzla! + long two = BitwuzlaJNI.bitwuzla_mk_fp_from_rational(fpSort, rm, "2", "1"); + + // 1 + 2 = a + long add = + BitwuzlaJNI.bitwuzla_mk_term3(BitwuzlaKind.BITWUZLA_KIND_FP_ADD.swigValue(), rm, two, one); + long eq = BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), add, a); + + BitwuzlaJNI.bitwuzla_assert(bitwuzla, eq); + long res = BitwuzlaJNI.bitwuzla_check_sat(bitwuzla); + assertThat(res).isEqualTo(BitwuzlaResult.BITWUZLA_SAT.swigValue()); + + // Get model value as String + String aString = BitwuzlaJNI.bitwuzla_term_to_string(a); + assertThat(aString).isEqualTo("a"); + String aValue = + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, a)); + + assertThat(aValue).isEqualTo("(fp #b0 #b10000 #b1000000000)"); + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(one)).isEqualTo("(fp #b0 #b01111 #b0000000000)"); + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(two)).isEqualTo("(fp #b0 #b10000 #b0000000000)"); + } + + @Test + public void testFpToBv() { + // A constant (BITWUZLA_KIND_CONSTANT) is both, a variable and a constant value + // However a value is also a BITWUZLA_KIND_VALUE, while a variable is not + long fpSort = BitwuzlaJNI.bitwuzla_mk_fp_sort(5, 11); + long rm = BitwuzlaJNI.bitwuzla_mk_rm_value(BitwuzlaJNI.BITWUZLA_RM_RTZ_get()); + long a = BitwuzlaJNI.bitwuzla_mk_const(fpSort, "a"); + long one = BitwuzlaJNI.bitwuzla_mk_fp_from_real(fpSort, rm, "-1"); + long two = BitwuzlaJNI.bitwuzla_mk_fp_from_real(fpSort, rm, "2"); + + long bvOne = + BitwuzlaJNI.bitwuzla_mk_term2_indexed1( + BitwuzlaKind.BITWUZLA_KIND_FP_TO_SBV.swigValue(), rm, one, 11 + 5); + long bvTwo = + BitwuzlaJNI.bitwuzla_mk_term2_indexed1( + BitwuzlaKind.BITWUZLA_KIND_FP_TO_SBV.swigValue(), rm, two, 11 + 5); + long add = + BitwuzlaJNI.bitwuzla_mk_term3(BitwuzlaKind.BITWUZLA_KIND_FP_ADD.swigValue(), rm, two, one); + long eq = BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), add, a); + + long bvA = + BitwuzlaJNI.bitwuzla_mk_term2_indexed1( + BitwuzlaKind.BITWUZLA_KIND_FP_TO_SBV.swigValue(), rm, a, 11 + 5); + long bvAdd = + BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_BV_ADD.swigValue(), bvOne, bvTwo); + long eqBv = + BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), bvAdd, bvA); + + BitwuzlaJNI.bitwuzla_assert(bitwuzla, eq); + BitwuzlaJNI.bitwuzla_assert(bitwuzla, eqBv); + long res = BitwuzlaJNI.bitwuzla_check_sat(bitwuzla); + assertThat(res).isEqualTo(BitwuzlaResult.BITWUZLA_SAT.swigValue()); + + String bvAString = + BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, bvA)); + + assertThat(bvAString).isEqualTo("#b0000000000000001"); + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, bvOne))) + .isEqualTo("#b1111111111111111"); + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(BitwuzlaJNI.bitwuzla_get_value(bitwuzla, bvTwo))) + .isEqualTo("#b0000000000000010"); + // Now test -0.9 to 0 and 0.9 to 0 + long nearlyMin1 = BitwuzlaJNI.bitwuzla_mk_fp_from_real(fpSort, rm, "-0.9"); + long nearly1 = BitwuzlaJNI.bitwuzla_mk_fp_from_real(fpSort, rm, "0.9"); + long bvnearlyMin1 = + BitwuzlaJNI.bitwuzla_mk_term2_indexed1( + BitwuzlaKind.BITWUZLA_KIND_FP_TO_SBV.swigValue(), rm, nearlyMin1, 11 + 5); + long bvnearly1 = + BitwuzlaJNI.bitwuzla_mk_term2_indexed1( + BitwuzlaKind.BITWUZLA_KIND_FP_TO_SBV.swigValue(), rm, nearly1, 11 + 5); + long b = BitwuzlaJNI.bitwuzla_mk_const(BitwuzlaJNI.bitwuzla_mk_bv_sort(11 + 5), "b"); + long bvAdd2 = + BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_BV_ADD.swigValue(), bvnearlyMin1, bvnearly1); + long eqBv2 = + BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), bvAdd2, b); + + BitwuzlaJNI.bitwuzla_assert(bitwuzla, eqBv2); + res = BitwuzlaJNI.bitwuzla_check_sat(bitwuzla); + assertThat(res).isEqualTo(BitwuzlaResult.BITWUZLA_SAT.swigValue()); + + assertThat( + BitwuzlaJNI.bitwuzla_term_to_string( + BitwuzlaJNI.bitwuzla_get_value(bitwuzla, bvnearlyMin1))) + .isEqualTo("#b0000000000000000"); + assertThat( + BitwuzlaJNI.bitwuzla_term_to_string( + BitwuzlaJNI.bitwuzla_get_value(bitwuzla, bvnearly1))) + .isEqualTo("#b0000000000000000"); + } + + @Test + public void testTypes() { + // A constant (BITWUZLA_KIND_CONSTANT) is both, a variable and a constant value + // However a value is also a BITWUZLA_KIND_VALUE, while a variable is not + long fpSort = BitwuzlaJNI.bitwuzla_mk_fp_sort(5, 11); + long rm = BitwuzlaJNI.bitwuzla_mk_rm_value(BitwuzlaJNI.BITWUZLA_RM_RNE_get()); + long a = BitwuzlaJNI.bitwuzla_mk_const(fpSort, "a"); + long one = BitwuzlaJNI.bitwuzla_mk_fp_from_real(fpSort, rm, "1"); + long two = BitwuzlaJNI.bitwuzla_mk_fp_from_real(fpSort, rm, "2"); + + long boolSort = BitwuzlaJNI.bitwuzla_mk_bool_sort(); + // long res = bitwuzlaJNI.bitwuzla_mk_const(boolSort, "res"); + long bvSort8 = BitwuzlaJNI.bitwuzla_mk_bv_sort(8); + long arg1 = BitwuzlaJNI.bitwuzla_mk_const(bvSort8, "arg1"); + long arg2 = BitwuzlaJNI.bitwuzla_mk_bv_value_uint64(bvSort8, 11); + long[] domain = {bvSort8, bvSort8}; + long sortFun = BitwuzlaJNI.bitwuzla_mk_fun_sort(2, domain, boolSort); + + // (applied) UFs have 1 + arity children, the UF decl (in this case foo), then the arguments + // in order. Applied UFs are also no "fun", but can only be discerned by KIND + // The decl has no children, but you can get domain and codomain with API calls + long foo = BitwuzlaJNI.bitwuzla_mk_const(sortFun, "foo"); + long appliedFoo = + BitwuzlaJNI.bitwuzla_mk_term3( + BitwuzlaKind.BITWUZLA_KIND_APPLY.swigValue(), foo, arg1, arg2); + assertThat(BitwuzlaJNI.bitwuzla_term_is_fun(appliedFoo)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_bool(appliedFoo)).isTrue(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_bool(BitwuzlaJNI.bitwuzla_term_get_sort(appliedFoo))) + .isTrue(); + assertThat(BitwuzlaJNI.bitwuzla_term_get_symbol(appliedFoo)).isNull(); + assertThat(BitwuzlaJNI.bitwuzla_term_get_symbol(foo)).isEqualTo("foo"); + assertThat(BitwuzlaJNI.bitwuzla_term_is_const(foo)).isTrue(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_fun(foo)).isTrue(); + long[] appliedFooChildren = BitwuzlaJNI.bitwuzla_term_get_children(appliedFoo, new long[1]); + assertThat(appliedFooChildren[0]).isEqualTo(foo); + assertThat(appliedFooChildren[1]).isEqualTo(arg1); + assertThat(appliedFooChildren[2]).isEqualTo(arg2); + assertThat(BitwuzlaJNI.bitwuzla_term_get_children(appliedFooChildren[0], new long[1])) + .isEmpty(); + assertThat(BitwuzlaJNI.bitwuzla_term_get_kind(appliedFoo)) + .isEqualTo(BitwuzlaKind.BITWUZLA_KIND_APPLY.swigValue()); + assertThat(BitwuzlaJNI.bitwuzla_term_get_kind(foo)) + .isEqualTo(BitwuzlaKind.BITWUZLA_KIND_CONSTANT.swigValue()); + + long add = + BitwuzlaJNI.bitwuzla_mk_term3(BitwuzlaKind.BITWUZLA_KIND_FP_ADD.swigValue(), rm, two, one); + long eq = BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), add, a); + long neg = BitwuzlaJNI.bitwuzla_mk_term1(BitwuzlaKind.BITWUZLA_KIND_NOT.swigValue(), eq); + + // The type of add is fp (a bv add would be bv) + assertThat(BitwuzlaJNI.bitwuzla_term_is_fp(add)).isTrue(); + // eq is bool + assertThat(BitwuzlaJNI.bitwuzla_term_is_bool(eq)).isTrue(); + // neg is also bool + assertThat(BitwuzlaJNI.bitwuzla_term_is_bool(neg)).isTrue(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_fun(neg)).isFalse(); + + // Non-UF functions consist of a KIND and arguments. + // You can get the KIND w bitwuzla_term_get_kind() and the arguments in the correct order w + // bitwuzla_term_get_children() + assertThat(BitwuzlaJNI.bitwuzla_term_is_fun(appliedFoo)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_fun(add)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_fun(eq)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_fun(neg)).isFalse(); + + assertThat(BitwuzlaJNI.bitwuzla_term_is_rm(rm)).isTrue(); + + long aSort = BitwuzlaJNI.bitwuzla_term_get_sort(a); + assertThat(BitwuzlaJNI.bitwuzla_term_is_bv_value(a)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_fp(aSort)).isTrue(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_const(aSort)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_fp(a)).isTrue(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_var(a)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_value(a)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_term_get_kind(a)) + .isEqualTo(BitwuzlaKind.BITWUZLA_KIND_CONSTANT.swigValue()); + + assertThat(BitwuzlaJNI.bitwuzla_sort_is_fun(aSort)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_fp(aSort)).isTrue(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_rm(aSort)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_bool(aSort)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_bv(aSort)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_array(aSort)).isFalse(); + + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(a)).isEqualTo("a"); + + long oneSort = BitwuzlaJNI.bitwuzla_term_get_sort(one); + assertThat(BitwuzlaJNI.bitwuzla_term_get_kind(one)) + .isEqualTo(BitwuzlaKind.BITWUZLA_KIND_VALUE.swigValue()); + assertThat(BitwuzlaJNI.bitwuzla_term_get_kind(one)) + .isNotEqualTo(BitwuzlaKind.BITWUZLA_KIND_VARIABLE.swigValue()); + assertThat(BitwuzlaJNI.bitwuzla_term_get_kind(one)) + .isNotEqualTo(BitwuzlaKind.BITWUZLA_KIND_CONSTANT.swigValue()); + assertThat(BitwuzlaJNI.bitwuzla_term_is_bv_value(one)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_fp(oneSort)).isTrue(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_const(oneSort)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_fp(one)).isTrue(); + assertThat(BitwuzlaJNI.bitwuzla_term_is_var(one)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_fun(oneSort)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_fp(oneSort)).isTrue(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_rm(oneSort)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_bool(oneSort)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_bv(oneSort)).isFalse(); + assertThat(BitwuzlaJNI.bitwuzla_sort_is_array(oneSort)).isFalse(); + + assertThat(BitwuzlaJNI.bitwuzla_term_to_string(one)).isEqualTo("(fp #b0 #b01111 #b0000000000)"); + } + + /* + * This serves as a testbed for indexed terms + */ + @Test + public void testExtend() { + long bvSort8 = BitwuzlaJNI.bitwuzla_mk_bv_sort(8); + long bvSort10 = BitwuzlaJNI.bitwuzla_mk_bv_sort(10); + long x = BitwuzlaJNI.bitwuzla_mk_const(bvSort8, "x"); + long y = BitwuzlaJNI.bitwuzla_mk_const(bvSort10, "y"); + long xExt = + BitwuzlaJNI.bitwuzla_mk_term1_indexed1( + BitwuzlaKind.BITWUZLA_KIND_BV_SIGN_EXTEND.swigValue(), x, 2); + long xExtEqY = + BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), xExt, y); + BitwuzlaJNI.bitwuzla_assert(bitwuzla, xExtEqY); + long res = BitwuzlaJNI.bitwuzla_check_sat(bitwuzla); + assertThat(res).isEqualTo(BitwuzlaResult.BITWUZLA_SAT.swigValue()); + + long[] children = BitwuzlaJNI.bitwuzla_term_get_children(xExt, new long[1]); + assertThat(children).hasLength(1); + assertThat(BitwuzlaJNI.bitwuzla_term_is_indexed(xExt)).isTrue(); + long[] len = new long[1]; + long[] indices = BitwuzlaJNI.bitwuzla_term_get_indices(xExt, len); + assertThat(indices).hasLength(1); + assertThat(indices[0]).isEqualTo(2); + } + + // Todo: + @Ignore + @Test + public void testExists() { + // EXISTS x, y . x = z AND y = z implies x = y + long bvSort8 = BitwuzlaJNI.bitwuzla_mk_bv_sort(8); + long x = BitwuzlaJNI.bitwuzla_mk_const(bvSort8, "x"); + long y = BitwuzlaJNI.bitwuzla_mk_const(bvSort8, "y"); + long z = BitwuzlaJNI.bitwuzla_mk_const(bvSort8, "z"); + + long xEqZ = BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), x, z); + long yEqZ = BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), y, z); + long xEqY = BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_EQUAL.swigValue(), x, y); + long formula = + BitwuzlaJNI.bitwuzla_mk_term2( + BitwuzlaKind.BITWUZLA_KIND_IMPLIES.swigValue(), + BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_AND.swigValue(), xEqZ, yEqZ), + xEqY); + + // Substitute the free vars with bound vars + long xB = BitwuzlaJNI.bitwuzla_mk_var(bvSort8, "x"); + long yB = BitwuzlaJNI.bitwuzla_mk_var(bvSort8, "y"); + // Substitution does not return a new term, but modifies the existing! + BitwuzlaJNI.bitwuzla_substitute_terms( + 1, new long[] {formula}, 2, new long[] {x, y}, new long[] {xB, yB}); + // Build quantifier + long[] argsAndBody = {xB, yB, formula}; + long ex = + BitwuzlaJNI.bitwuzla_mk_term( + BitwuzlaKind.BITWUZLA_KIND_FORALL.swigValue(), argsAndBody.length, argsAndBody); + + // Check SAT + BitwuzlaJNI.bitwuzla_assert(bitwuzla, ex); + long res = BitwuzlaJNI.bitwuzla_check_sat(bitwuzla); + assertThat(res).isEqualTo(BitwuzlaResult.BITWUZLA_UNSAT.swigValue()); + + // Model + } + + private static final String SMT2DUMP = + "(declare-fun a () Bool)\n" + + "(declare-fun b () Bool)\n" + + "(declare-fun d () Bool)\n" + + "(declare-fun e () Bool)\n" + + "(define-fun .def_9 () Bool (= a b))\n" + + "(define-fun .def_10 () Bool (not .def_9))\n" + + "(define-fun .def_13 () Bool (and .def_10 d))\n" + + "(define-fun .def_14 () Bool (or e .def_13))\n" + + "(assert .def_14)"; + + // Bitwuzla currently REWRITES terms when parsing + @Ignore + @Test + public void parserTest2() { + long[] terms = BitwuzlaJNI.parse(SMT2DUMP); + BitwuzlaJNI.bitwuzla_push(bitwuzla, 1); + BitwuzlaJNI.bitwuzla_assert(bitwuzla, terms[0]); + String newDump = BitwuzlaJNI.dump_assertions_smt2(bitwuzla, 10); + if (newDump.contains("(check-sat)")) { + newDump = newDump.replace("(check-sat)", ""); + } + if (newDump.contains("(exit)")) { + newDump = newDump.replace("(exit)", ""); + } + assertThat(newDump).isEqualTo(SMT2DUMP); + } + + @Test + public void parserTest() { + long boolSort = BitwuzlaJNI.bitwuzla_mk_bool_sort(); + long x = BitwuzlaJNI.bitwuzla_mk_const(boolSort, "x"); + long y = BitwuzlaJNI.bitwuzla_mk_const(boolSort, "y"); + long xOrY = BitwuzlaJNI.bitwuzla_mk_term2(BitwuzlaKind.BITWUZLA_KIND_XOR.swigValue(), x, y); + BitwuzlaJNI.bitwuzla_push(bitwuzla, 1); + BitwuzlaJNI.bitwuzla_assert(bitwuzla, xOrY); + + String dump = BitwuzlaJNI.dump_assertions_smt2(bitwuzla, 10); + System.out.println(dump); + // check-sat and exit messes with the parse, in that suddenly sat is checked and the formulas + // are rewritten and then returned in a different form, independent of options + + BitwuzlaJNI.bitwuzla_pop(bitwuzla, 1); + + long[] terms = BitwuzlaJNI.parse(dump); + + BitwuzlaJNI.bitwuzla_push(bitwuzla, 1); + BitwuzlaJNI.bitwuzla_assert(bitwuzla, terms[0]); + String newDump = BitwuzlaJNI.dump_assertions_smt2(bitwuzla, 10); + assertThat(newDump).isEqualTo(dump); + } + + @Ignore + @Test + public void parserFailTest() { + // valid + String input = "(declare-const a Bool)\n(declare-const b Bool)\n(assert (or a b))"; + long[] terms = BitwuzlaJNI.parse(input); + assertThat(terms).isNotNull(); + // invalid/fails + String badInput = "(declare-const a Bool)\n(assert (or a b))"; + terms = BitwuzlaJNI.parse(badInput); + assertThat(terms).isNotNull(); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaOption.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaOption.java new file mode 100644 index 0000000000..cde8c35a58 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaOption.java @@ -0,0 +1,173 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +public final class BitwuzlaOption { + + private static int swigNext = 0; + private final int swigValue; + private final String swigName; + public static final BitwuzlaOption BITWUZLA_OPT_LOGLEVEL = + new BitwuzlaOption("BITWUZLA_OPT_LOGLEVEL"); + public static final BitwuzlaOption BITWUZLA_OPT_PRODUCE_MODELS = + new BitwuzlaOption("BITWUZLA_OPT_PRODUCE_MODELS"); + public static final BitwuzlaOption BITWUZLA_OPT_PRODUCE_UNSAT_ASSUMPTIONS = + new BitwuzlaOption("BITWUZLA_OPT_PRODUCE_UNSAT_ASSUMPTIONS"); + public static final BitwuzlaOption BITWUZLA_OPT_PRODUCE_UNSAT_CORES = + new BitwuzlaOption("BITWUZLA_OPT_PRODUCE_UNSAT_CORES"); + public static final BitwuzlaOption BITWUZLA_OPT_SEED = new BitwuzlaOption("BITWUZLA_OPT_SEED"); + public static final BitwuzlaOption BITWUZLA_OPT_VERBOSITY = + new BitwuzlaOption("BITWUZLA_OPT_VERBOSITY"); + public static final BitwuzlaOption BITWUZLA_OPT_TIME_LIMIT_PER = + new BitwuzlaOption("BITWUZLA_OPT_TIME_LIMIT_PER"); + + public static final BitwuzlaOption BITWUZLA_OPT_MEMORY_LIMIT = + new BitwuzlaOption("BITWUZLA_OPT_MEMORY_LIMIT"); + public static final BitwuzlaOption BITWUZLA_OPT_BV_SOLVER = + new BitwuzlaOption("BITWUZLA_OPT_BV_SOLVER"); + public static final BitwuzlaOption BITWUZLA_OPT_REWRITE_LEVEL = + new BitwuzlaOption("BITWUZLA_OPT_REWRITE_LEVEL"); + public static final BitwuzlaOption BITWUZLA_OPT_SAT_SOLVER = + new BitwuzlaOption("BITWUZLA_OPT_SAT_SOLVER"); + public static final BitwuzlaOption BITWUZLA_OPT_PROP_CONST_BITS = + new BitwuzlaOption("BITWUZLA_OPT_PROP_CONST_BITS"); + public static final BitwuzlaOption BITWUZLA_OPT_PROP_INFER_INEQ_BOUNDS = + new BitwuzlaOption("BITWUZLA_OPT_PROP_INFER_INEQ_BOUNDS"); + public static final BitwuzlaOption BITWUZLA_OPT_PROP_NPROPS = + new BitwuzlaOption("BITWUZLA_OPT_PROP_NPROPS"); + public static final BitwuzlaOption BITWUZLA_OPT_PROP_NUPDATES = + new BitwuzlaOption("BITWUZLA_OPT_PROP_NUPDATES"); + public static final BitwuzlaOption BITWUZLA_OPT_PROP_OPT_LT_CONCAT_SEXT = + new BitwuzlaOption("BITWUZLA_OPT_PROP_OPT_LT_CONCAT_SEXT"); + public static final BitwuzlaOption BITWUZLA_OPT_PROP_PATH_SEL = + new BitwuzlaOption("BITWUZLA_OPT_PROP_PATH_SEL"); + public static final BitwuzlaOption BITWUZLA_OPT_PROP_PROB_RANDOM_INPUT = + new BitwuzlaOption("BITWUZLA_OPT_PROP_PROB_RANDOM_INPUT"); + public static final BitwuzlaOption BITWUZLA_OPT_PROP_PROB_USE_INV_VALUE = + new BitwuzlaOption("BITWUZLA_OPT_PROP_PROB_USE_INV_VALUE"); + public static final BitwuzlaOption BITWUZLA_OPT_PROP_SEXT = + new BitwuzlaOption("BITWUZLA_OPT_PROP_SEXT"); + public static final BitwuzlaOption BITWUZLA_OPT_PROP_NORMALIZE = + new BitwuzlaOption("BITWUZLA_OPT_PROP_NORMALIZE"); + public static final BitwuzlaOption BITWUZLA_OPT_PREPROCESS = + new BitwuzlaOption("BITWUZLA_OPT_PREPROCESS"); + public static final BitwuzlaOption BITWUZLA_OPT_PP_CONTRADICTING_ANDS = + new BitwuzlaOption("BITWUZLA_OPT_PP_CONTRADICTING_ANDS"); + public static final BitwuzlaOption BITWUZLA_OPT_PP_ELIM_BV_EXTRACTS = + new BitwuzlaOption("BITWUZLA_OPT_PP_ELIM_BV_EXTRACTS"); + public static final BitwuzlaOption BITWUZLA_OPT_PP_EMBEDDED_CONSTR = + new BitwuzlaOption("BITWUZLA_OPT_PP_EMBEDDED_CONSTR"); + public static final BitwuzlaOption BITWUZLA_OPT_PP_FLATTEN_AND = + new BitwuzlaOption("BITWUZLA_OPT_PP_FLATTEN_AND"); + public static final BitwuzlaOption BITWUZLA_OPT_PP_NORMALIZE = + new BitwuzlaOption("BITWUZLA_OPT_PP_NORMALIZE"); + public static final BitwuzlaOption BITWUZLA_OPT_PP_NORMALIZE_SHARE_AWARE = + new BitwuzlaOption("BITWUZLA_OPT_PP_NORMALIZE_SHARE_AWARE"); + public static final BitwuzlaOption BITWUZLA_OPT_PP_SKELETON_PREPROC = + new BitwuzlaOption("BITWUZLA_OPT_PP_SKELETON_PREPROC"); + public static final BitwuzlaOption BITWUZLA_OPT_PP_VARIABLE_SUBST = + new BitwuzlaOption("BITWUZLA_OPT_PP_VARIABLE_SUBST"); + public static final BitwuzlaOption BITWUZLA_OPT_PP_VARIABLE_SUBST_NORM_EQ = + new BitwuzlaOption("BITWUZLA_OPT_PP_VARIABLE_SUBST_NORM_EQ"); + public static final BitwuzlaOption BITWUZLA_OPT_PP_VARIABLE_SUBST_NORM_DISEQ = + new BitwuzlaOption("BITWUZLA_OPT_PP_VARIABLE_SUBST_NORM_DISEQ"); + public static final BitwuzlaOption BITWUZLA_OPT_PP_VARIABLE_SUBST_NORM_BV_INEQ = + new BitwuzlaOption("BITWUZLA_OPT_PP_VARIABLE_SUBST_NORM_BV_INEQ"); + public static final BitwuzlaOption BITWUZLA_OPT_DBG_RW_NODE_THRESH = + new BitwuzlaOption("BITWUZLA_OPT_DBG_RW_NODE_THRESH"); + public static final BitwuzlaOption BITWUZLA_OPT_DBG_PP_NODE_THRESH = + new BitwuzlaOption("BITWUZLA_OPT_DBG_PP_NODE_THRESH"); + public static final BitwuzlaOption BITWUZLA_OPT_DBG_CHECK_MODEL = + new BitwuzlaOption("BITWUZLA_OPT_DBG_CHECK_MODEL"); + public static final BitwuzlaOption BITWUZLA_OPT_DBG_CHECK_UNSAT_CORE = + new BitwuzlaOption("BITWUZLA_OPT_DBG_CHECK_UNSAT_CORE"); + public static final BitwuzlaOption BITWUZLA_OPT_NUM_OPTS = + new BitwuzlaOption("BITWUZLA_OPT_NUM_OPTS"); + + public int swigValue() { + return swigValue; + } + + @Override + public String toString() { + return swigName; + } + + public static BitwuzlaOption swigToEnum(int swigValue) { + if (swigValue < swigValues.length + && swigValue >= 0 + && swigValues[swigValue].swigValue == swigValue) { + return swigValues[swigValue]; + } + for (int i = 0; i < swigValues.length; i++) { + if (swigValues[i].swigValue == swigValue) { + return swigValues[i]; + } + } + throw new IllegalArgumentException( + "No enum " + BitwuzlaOption.class + " with value " + swigValue); + } + + // Suppress because of SWIG magic + @SuppressWarnings("StaticAssignmentInConstructor") + private BitwuzlaOption(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + // Keep in the same order as option.h! + private static BitwuzlaOption[] swigValues = { + BITWUZLA_OPT_LOGLEVEL, + BITWUZLA_OPT_PRODUCE_MODELS, + BITWUZLA_OPT_PRODUCE_UNSAT_ASSUMPTIONS, + BITWUZLA_OPT_PRODUCE_UNSAT_CORES, + BITWUZLA_OPT_SEED, + BITWUZLA_OPT_VERBOSITY, + BITWUZLA_OPT_TIME_LIMIT_PER, + BITWUZLA_OPT_MEMORY_LIMIT, + BITWUZLA_OPT_BV_SOLVER, + BITWUZLA_OPT_REWRITE_LEVEL, + BITWUZLA_OPT_SAT_SOLVER, + BITWUZLA_OPT_PROP_CONST_BITS, + BITWUZLA_OPT_PROP_INFER_INEQ_BOUNDS, + BITWUZLA_OPT_PROP_NPROPS, + BITWUZLA_OPT_PROP_NUPDATES, + BITWUZLA_OPT_PROP_OPT_LT_CONCAT_SEXT, + BITWUZLA_OPT_PROP_PATH_SEL, + BITWUZLA_OPT_PROP_PROB_RANDOM_INPUT, + BITWUZLA_OPT_PROP_PROB_USE_INV_VALUE, + BITWUZLA_OPT_PROP_SEXT, + BITWUZLA_OPT_PROP_NORMALIZE, + BITWUZLA_OPT_PREPROCESS, + BITWUZLA_OPT_PP_CONTRADICTING_ANDS, + BITWUZLA_OPT_PP_ELIM_BV_EXTRACTS, + BITWUZLA_OPT_PP_EMBEDDED_CONSTR, + BITWUZLA_OPT_PP_FLATTEN_AND, + BITWUZLA_OPT_PP_NORMALIZE, + BITWUZLA_OPT_PP_NORMALIZE_SHARE_AWARE, + BITWUZLA_OPT_PP_SKELETON_PREPROC, + BITWUZLA_OPT_PP_VARIABLE_SUBST, + BITWUZLA_OPT_PP_VARIABLE_SUBST_NORM_EQ, + BITWUZLA_OPT_PP_VARIABLE_SUBST_NORM_DISEQ, + BITWUZLA_OPT_PP_VARIABLE_SUBST_NORM_BV_INEQ, + BITWUZLA_OPT_DBG_RW_NODE_THRESH, + BITWUZLA_OPT_DBG_PP_NODE_THRESH, + BITWUZLA_OPT_DBG_CHECK_MODEL, + BITWUZLA_OPT_DBG_CHECK_UNSAT_CORE, + BITWUZLA_OPT_NUM_OPTS, + }; +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaOptionInfo.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaOptionInfo.java new file mode 100644 index 0000000000..2bdc1e463b --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaOptionInfo.java @@ -0,0 +1,86 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +public class BitwuzlaOptionInfo { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected BitwuzlaOptionInfo(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(BitwuzlaOptionInfo obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + BitwuzlaJNI.delete_BitwuzlaOptionInfo(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setOpt(BitwuzlaOption value) { + BitwuzlaJNI.BitwuzlaOptionInfo_opt_set(swigCPtr, this, value.swigValue()); + } + + public BitwuzlaOption getOpt() { + return BitwuzlaOption.swigToEnum(BitwuzlaJNI.BitwuzlaOptionInfo_opt_get(swigCPtr, this)); + } + + public void setShrt(String value) { + BitwuzlaJNI.BitwuzlaOptionInfo_shrt_set(swigCPtr, this, value); + } + + public String getShrt() { + return BitwuzlaJNI.BitwuzlaOptionInfo_shrt_get(swigCPtr, this); + } + + public void setLng(String value) { + BitwuzlaJNI.BitwuzlaOptionInfo_lng_set(swigCPtr, this, value); + } + + public String getLng() { + return BitwuzlaJNI.BitwuzlaOptionInfo_lng_get(swigCPtr, this); + } + + public void setDescription(String value) { + BitwuzlaJNI.BitwuzlaOptionInfo_description_set(swigCPtr, this, value); + } + + public String getDescription() { + return BitwuzlaJNI.BitwuzlaOptionInfo_description_get(swigCPtr, this); + } + + public void setNumeric(NumericValue value) { + BitwuzlaJNI.BitwuzlaOptionInfo_numeric_set(swigCPtr, this, NumericValue.getCPtr(value), value); + } + + public NumericValue getNumeric() { + long cPtr = BitwuzlaJNI.BitwuzlaOptionInfo_numeric_get(swigCPtr, this); + return (cPtr == 0) ? null : new NumericValue(cPtr, false); + } + + public BitwuzlaOptionInfo() { + this(BitwuzlaJNI.new_BitwuzlaOptionInfo(), true); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaQuantifiedFormulaManager.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaQuantifiedFormulaManager.java new file mode 100644 index 0000000000..c19529c4f4 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaQuantifiedFormulaManager.java @@ -0,0 +1,67 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import static com.google.common.base.Preconditions.checkArgument; + +import java.util.List; +import org.sosy_lab.java_smt.api.SolverException; +import org.sosy_lab.java_smt.basicimpl.AbstractQuantifiedFormulaManager; +import org.sosy_lab.java_smt.basicimpl.FormulaCreator; + +public class BitwuzlaQuantifiedFormulaManager + extends AbstractQuantifiedFormulaManager { + + protected BitwuzlaQuantifiedFormulaManager( + FormulaCreator pCreator) { + super(pCreator); + } + + @Override + protected Long eliminateQuantifiers(Long pExtractInfo) + throws SolverException, InterruptedException { + throw new UnsupportedOperationException("Bitwuzla does not support eliminating Quantifiers."); + } + + @Override + public Long mkQuantifier(Quantifier q, List vars, Long body) { + checkArgument( + !vars.isEmpty(), "The list of bound variables for a quantifier may not be empty."); + long[] origVars = new long[vars.size()]; + long[] substVars = new long[vars.size()]; + + for (int i = 0; i < vars.size(); i++) { + long var = vars.get(i); + origVars[i] = var; + // Create/Use bound vars + long boundCopy = ((BitwuzlaFormulaCreator) formulaCreator).makeBoundVariable(var); + substVars[i] = boundCopy; + } + long substBody = BitwuzlaJNI.bitwuzla_substitute_term(body, vars.size(), origVars, substVars); + + long[] argsAndBody = new long[2]; + argsAndBody[1] = substBody; + long currentFormula = substBody; + for (int i = 0; i < vars.size(); i++) { + argsAndBody[0] = substVars[i]; + if (q.equals(Quantifier.FORALL)) { + currentFormula = + BitwuzlaJNI.bitwuzla_mk_term( + BitwuzlaKind.BITWUZLA_KIND_FORALL.swigValue(), argsAndBody.length, argsAndBody); + + } else { + currentFormula = + BitwuzlaJNI.bitwuzla_mk_term( + BitwuzlaKind.BITWUZLA_KIND_EXISTS.swigValue(), argsAndBody.length, argsAndBody); + } + argsAndBody[1] = currentFormula; + } + return currentFormula; + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaResult.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaResult.java new file mode 100644 index 0000000000..4b79528fbd --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaResult.java @@ -0,0 +1,73 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +public final class BitwuzlaResult { + + private static int swigNext = 0; + private final int swigValue; + private final String swigName; + public static final BitwuzlaResult BITWUZLA_SAT = + BitwuzlaResult.of("BITWUZLA_SAT", BitwuzlaJNI.BITWUZLA_SAT_get()); + public static final BitwuzlaResult BITWUZLA_UNSAT = + BitwuzlaResult.of("BITWUZLA_UNSAT", BitwuzlaJNI.BITWUZLA_UNSAT_get()); + public static final BitwuzlaResult BITWUZLA_UNKNOWN = + BitwuzlaResult.of("BITWUZLA_UNKNOWN", BitwuzlaJNI.BITWUZLA_UNKNOWN_get()); + + private static BitwuzlaResult[] swigValues = {BITWUZLA_SAT, BITWUZLA_UNSAT, BITWUZLA_UNKNOWN}; + + public int swigValue() { + return swigValue; + } + + @Override + public String toString() { + return swigName; + } + + public static BitwuzlaResult swigToEnum(int swigValue) { + if (swigValue < swigValues.length + && swigValue >= 0 + && swigValues[swigValue].swigValue == swigValue) { + return swigValues[swigValue]; + } + for (int i = 0; i < swigValues.length; i++) { + if (swigValues[i].swigValue == swigValue) { + return swigValues[i]; + } + } + throw new IllegalArgumentException( + "No enum " + BitwuzlaResult.class + " with value " + swigValue); + } + + @SuppressWarnings("unused") + private BitwuzlaResult(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private BitwuzlaResult(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + } + + private static BitwuzlaResult of(String swigName, int swigValue) { + BitwuzlaResult res = new BitwuzlaResult(swigName, swigValue); + BitwuzlaResult.swigNext = res.swigValue + 1; + return res; + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaSolverContext.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaSolverContext.java new file mode 100644 index 0000000000..ea35f25c29 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaSolverContext.java @@ -0,0 +1,275 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import com.google.common.base.Preconditions; +import com.google.common.base.Splitter; +import com.google.common.base.Splitter.MapSplitter; +import com.google.common.collect.ImmutableMap; +import java.lang.reflect.Field; +import java.util.Collection; +import java.util.Locale; +import java.util.Map; +import java.util.Set; +import java.util.function.Consumer; +import org.checkerframework.checker.nullness.qual.Nullable; +import org.sosy_lab.common.ShutdownNotifier; +import org.sosy_lab.common.configuration.Configuration; +import org.sosy_lab.common.configuration.InvalidConfigurationException; +import org.sosy_lab.common.configuration.Option; +import org.sosy_lab.common.configuration.Options; +import org.sosy_lab.common.io.PathCounterTemplate; +import org.sosy_lab.java_smt.SolverContextFactory.Solvers; +import org.sosy_lab.java_smt.api.FloatingPointRoundingMode; +import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment; +import org.sosy_lab.java_smt.api.OptimizationProverEnvironment; +import org.sosy_lab.java_smt.api.ProverEnvironment; +import org.sosy_lab.java_smt.basicimpl.AbstractSolverContext; + +public final class BitwuzlaSolverContext extends AbstractSolverContext { + + @Options(prefix = "solver.bitwuzla") + public static class BitwuzlaSettings { + + enum SatSolver { + LINGELING, + CMS, + CADICAL, + KISSAT + } + + @Option(secure = true, description = "The SAT solver used by Bitwuzla.") + private SatSolver satSolver = SatSolver.CADICAL; + + @Option( + secure = true, + description = + "Further options for Bitwuzla in addition to the default options. " + + "Format: \"Optionname=value\" with ’,’ to seperate options. " + + "Optionname and value can be found in BtorOption or Bitwuzla C Api." + + "Example: \"BTOR_OPT_MODEL_GEN=2,BTOR_OPT_INCREMENTAL=1\".") + private String furtherOptions = ""; + + protected SatSolver getSatSolver() { + return satSolver; + } + + protected String getFurtherOptions() { + return furtherOptions; + } + + BitwuzlaSettings(Configuration config) throws InvalidConfigurationException { + config.inject(this); + } + } + + private final BitwuzlaFormulaManager manager; + private final BitwuzlaFormulaCreator creator; + private final ShutdownNotifier shutdownNotifier; + + private final BitwuzlaSettings settings; + + private final long randomSeed; + + private boolean closed = false; + + BitwuzlaSolverContext( + BitwuzlaFormulaManager pManager, + BitwuzlaFormulaCreator pCreator, + ShutdownNotifier pShutdownNotifier, + long pRandomSeed, + BitwuzlaSettings pSettings) { + super(pManager); + manager = pManager; + creator = pCreator; + shutdownNotifier = pShutdownNotifier; + randomSeed = pRandomSeed; + settings = pSettings; + } + + @SuppressWarnings("unused") + public static BitwuzlaSolverContext create( + Configuration config, + ShutdownNotifier pShutdownNotifier, + @Nullable PathCounterTemplate solverLogfile, + long randomSeed, + FloatingPointRoundingMode pFloatingPointRoundingMode, + Consumer pLoader) + throws InvalidConfigurationException { + pLoader.accept("bitwuzlaJNI"); + + BitwuzlaSettings settings = new BitwuzlaSettings(config); + final long bitwuzla = createEnvironmentBasedOnOptions(settings, randomSeed); + + BitwuzlaFormulaCreator creator = new BitwuzlaFormulaCreator(bitwuzla); + BitwuzlaUFManager functionTheory = new BitwuzlaUFManager(creator); + BitwuzlaBooleanFormulaManager booleanTheory = new BitwuzlaBooleanFormulaManager(creator); + BitwuzlaBitvectorFormulaManager bitvectorTheory = + new BitwuzlaBitvectorFormulaManager(creator, booleanTheory); + BitwuzlaQuantifiedFormulaManager quantifierTheory = + new BitwuzlaQuantifiedFormulaManager(creator); + BitwuzlaFloatingPointManager floatingPointTheory = + new BitwuzlaFloatingPointManager(creator, pFloatingPointRoundingMode); + BitwuzlaArrayFormulaManager arrayTheory = new BitwuzlaArrayFormulaManager(creator); + BitwuzlaFormulaManager manager = + new BitwuzlaFormulaManager( + creator, + functionTheory, + booleanTheory, + bitvectorTheory, + quantifierTheory, + floatingPointTheory, + arrayTheory); + + return new BitwuzlaSolverContext(manager, creator, pShutdownNotifier, randomSeed, settings); + } + + private static long createEnvironmentBasedOnOptions(BitwuzlaSettings settings, long randomSeed) + throws InvalidConfigurationException { + long options = BitwuzlaJNI.bitwuzla_options_new(); + + Preconditions.checkNotNull(settings.getSatSolver()); + BitwuzlaJNI.bitwuzla_set_option_mode( + options, + BitwuzlaOption.BITWUZLA_OPT_SAT_SOLVER.swigValue(), + settings.getSatSolver().name().toLowerCase(Locale.getDefault())); + BitwuzlaJNI.bitwuzla_set_option( + options, BitwuzlaOption.BITWUZLA_OPT_PRODUCE_MODELS.swigValue(), 2); + BitwuzlaJNI.bitwuzla_set_option( + options, BitwuzlaOption.BITWUZLA_OPT_SEED.swigValue(), randomSeed); + // Stop Bitwuzla from rewriting formulas in outputs + BitwuzlaJNI.bitwuzla_set_option( + options, BitwuzlaOption.BITWUZLA_OPT_REWRITE_LEVEL.swigValue(), 0); + + setFurtherOptions(options, settings.getFurtherOptions()); + + return BitwuzlaJNI.bitwuzla_new(options); + } + + /** + * Get version information out of the solver. + * + *

In most cases, the version contains the name of the solver followed by some numbers and + * additional info about the version, e.g., "SMTInterpol 2.5-12-g3d15a15c". + */ + @Override + public String getVersion() { + return "Bitwuzla " + BitwuzlaJNI.bitwuzla_version(); + } + + /** + * Get solver name (MATHSAT5/Z3/etc...). + * + *

This is an uppercase String matching the enum identifier from {@link Solvers} + */ + @Override + public Solvers getSolverName() { + return Solvers.BITWUZLA; + } + + /** + * Close the solver context. + * + *

After calling this method, further access to any object that had been returned from this + * context is not wanted, i.e., it depends on the solver. Java-based solvers might wait for the + * next garbage collection with any cleanup operation. Native solvers might even reference invalid + * memory and cause segmentation faults. + * + *

Necessary for the solvers implemented in native code, frees the associated memory. + */ + @Override + public void close() { + if (!closed) { + closed = true; + BitwuzlaJNI.bitwuzla_delete(creator.getEnv()); + } + } + + @Override + protected ProverEnvironment newProverEnvironment0(Set options) { + Preconditions.checkState(!closed, "solver context is already closed"); + + return new BitwuzlaTheoremProver( + manager, creator, shutdownNotifier, options, settings, randomSeed); + } + + @Override + protected InterpolatingProverEnvironment newProverEnvironmentWithInterpolation0( + Set pF) { + throw new UnsupportedOperationException("Bitwuzla does not support interpolation"); + } + + @Override + protected OptimizationProverEnvironment newOptimizationProverEnvironment0( + Set pSet) { + throw new UnsupportedOperationException("Bitwuzla does not support optimization"); + } + + /** + * Whether the solver supports solving under some given assumptions (with all corresponding + * features) by itself, i.e., whether {@link ProverEnvironment#isUnsatWithAssumptions(Collection)} + * and {@link InterpolatingProverEnvironment#isUnsatWithAssumptions(Collection)} are fully + * implemented. + * + *

Otherwise, i.e., if this method returns {@code false}, the solver does not need to support + * this feature and may simply {@code throw UnsupportedOperationException} in the respective + * methods. This class will wrap the prover environments and provide an implementation of the + * feature. + * + *

This method is expected to always return the same value. Otherwise, the behavior of this + * class is undefined. + */ + @Override + protected boolean supportsAssumptionSolving() { + return true; + } + + /** + * Set more options for Bitwuzla. + * + * @param pOptions options pointer + * @param pFurtherOptions String to be parsed with options to be set. + * @throws InvalidConfigurationException signals that the format of the option string is wrong or + * an invalid option is used. + */ + private static void setFurtherOptions(long pOptions, String pFurtherOptions) + throws InvalidConfigurationException { + MapSplitter optionSplitter = + Splitter.on(',') + .trimResults() + .omitEmptyStrings() + .withKeyValueSeparator(Splitter.on('=').limit(2).trimResults()); + ImmutableMap furtherOptionsMap; + + try { + furtherOptionsMap = ImmutableMap.copyOf(optionSplitter.split(pFurtherOptions)); + } catch (IllegalArgumentException e) { + throw new InvalidConfigurationException( + "Invalid Bitwuzla option in \"" + pFurtherOptions + "\": " + e.getMessage(), e); + } + for (Map.Entry option : furtherOptionsMap.entrySet()) { + try { + Class optionClass = BitwuzlaOption.class; + Field optionField = optionClass.getField(option.getKey()); + // Get the value of the public fields + BitwuzlaOption value = (BitwuzlaOption) optionField.get(null); + if (BitwuzlaJNI.bitwuzla_option_is_numeric(pOptions, value.swigValue())) { + long optionValue = Long.parseLong(option.getValue()); + BitwuzlaJNI.bitwuzla_set_option(pOptions, value.swigValue(), optionValue); + } else { + BitwuzlaJNI.bitwuzla_set_option_mode(pOptions, value.swigValue(), option.getValue()); + } + } catch (java.lang.NoSuchFieldException e) { + throw new InvalidConfigurationException(e.getMessage(), e); + } catch (IllegalAccessException pE) { + throw new RuntimeException("Problem with access to BitwuzlaOption Field", pE); + } + } + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaTheoremProver.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaTheoremProver.java new file mode 100644 index 0000000000..59f3ccead9 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaTheoremProver.java @@ -0,0 +1,257 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import com.google.common.base.Preconditions; +import com.google.common.collect.Collections2; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Locale; +import java.util.Optional; +import java.util.Set; +import org.checkerframework.checker.nullness.qual.Nullable; +import org.sosy_lab.common.ShutdownNotifier; +import org.sosy_lab.java_smt.api.BooleanFormula; +import org.sosy_lab.java_smt.api.Model; +import org.sosy_lab.java_smt.api.ProverEnvironment; +import org.sosy_lab.java_smt.api.SolverContext.ProverOptions; +import org.sosy_lab.java_smt.api.SolverException; +import org.sosy_lab.java_smt.basicimpl.AbstractProverWithAllSat; +import org.sosy_lab.java_smt.basicimpl.CachingModel; +import org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaFormula.BitwuzlaBooleanFormula; +import org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaJNI.TerminationCallback; +import org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaSolverContext.BitwuzlaSettings; + +class BitwuzlaTheoremProver extends AbstractProverWithAllSat implements ProverEnvironment { + + private final long env; + + @SuppressWarnings("unused") + private final BitwuzlaFormulaManager manager; + + private final BitwuzlaFormulaCreator creator; + protected boolean wasLastSatCheckSat = false; // and stack is not changed + + private final TerminationCallback terminationCallback; + private final long terminationCallbackHelper; + + protected BitwuzlaTheoremProver( + BitwuzlaFormulaManager pManager, + BitwuzlaFormulaCreator pCreator, + ShutdownNotifier pShutdownNotifier, + Set pOptions, + BitwuzlaSettings pSettings, + long pRandomSeed) { + super(pOptions, pManager.getBooleanFormulaManager(), pShutdownNotifier); + manager = pManager; + creator = pCreator; + // Bitwuzla guarantees that Terms and Sorts are shared + env = createEnvironment(pOptions, pSettings, pRandomSeed); + terminationCallback = shutdownNotifier::shouldShutdown; + terminationCallbackHelper = addTerminationCallback(); + } + + private long createEnvironment( + Set pFurtherOptions, BitwuzlaSettings pSettings, long pRandomSeed) { + // TODO: set further options + long options = BitwuzlaJNI.bitwuzla_options_new(); + + if (pFurtherOptions.contains(ProverOptions.GENERATE_MODELS) + || pFurtherOptions.contains(ProverOptions.GENERATE_ALL_SAT)) { + BitwuzlaJNI.bitwuzla_set_option( + options, BitwuzlaOption.BITWUZLA_OPT_PRODUCE_MODELS.swigValue(), 2); + } + + if (pFurtherOptions.contains(ProverOptions.GENERATE_UNSAT_CORE)) { + BitwuzlaJNI.bitwuzla_set_option( + options, BitwuzlaOption.BITWUZLA_OPT_PRODUCE_UNSAT_CORES.swigValue(), 2); + } + + if (pFurtherOptions.contains(ProverOptions.GENERATE_UNSAT_CORE_OVER_ASSUMPTIONS)) { + BitwuzlaJNI.bitwuzla_set_option( + options, BitwuzlaOption.BITWUZLA_OPT_PRODUCE_UNSAT_ASSUMPTIONS.swigValue(), 2); + } + // TODO: termination callback + // bitwuzlaJNI.bitwuzla_set_termination_callback(); + + Preconditions.checkNotNull(pSettings.getSatSolver()); + BitwuzlaJNI.bitwuzla_set_option_mode( + options, + BitwuzlaOption.BITWUZLA_OPT_SAT_SOLVER.swigValue(), + pSettings.getSatSolver().name().toLowerCase(Locale.getDefault())); + BitwuzlaJNI.bitwuzla_set_option( + options, BitwuzlaOption.BITWUZLA_OPT_SEED.swigValue(), pRandomSeed); + // Stop Bitwuzla from rewriting formulas in outputs + BitwuzlaJNI.bitwuzla_set_option( + options, BitwuzlaOption.BITWUZLA_OPT_REWRITE_LEVEL.swigValue(), 0); + + // setFurtherOptions(pOptions, settings.getFurtherOptions()); + + return BitwuzlaJNI.bitwuzla_new(options); + } + + /** + * Remove one backtracking point/level from the current stack. This removes the latest level + * including all of its formulas, i.e., all formulas that were added for this backtracking point. + */ + @Override + public void popImpl() { + BitwuzlaJNI.bitwuzla_pop(env, 1); + } + + @Override + public @Nullable Void addConstraintImpl(BooleanFormula constraint) throws InterruptedException { + wasLastSatCheckSat = false; + BitwuzlaJNI.bitwuzla_assert(env, ((BitwuzlaBooleanFormula) constraint).getTerm()); + return null; + } + + /** + * Create a new backtracking point, i.e., a new level on the assertion stack. Each level can hold + * several asserted formulas. + * + *

If formulas are added before creating the first backtracking point, they can not be removed + * via a POP-operation. + */ + @Override + public void pushImpl() throws InterruptedException { + BitwuzlaJNI.bitwuzla_push(env, 1); + } + + private boolean readSATResult(int resultValue) throws SolverException, InterruptedException { + if (resultValue == BitwuzlaResult.BITWUZLA_SAT.swigValue()) { + wasLastSatCheckSat = true; + return false; + } else if (resultValue == BitwuzlaResult.BITWUZLA_UNSAT.swigValue()) { + return true; + } else if (resultValue == BitwuzlaResult.BITWUZLA_UNKNOWN.swigValue() + && terminationCallback.shouldTerminate()) { + throw new InterruptedException("Bitwuzla interrupted."); + } else { + throw new SolverException("Bitwuzla returned UNKNOWN."); + } + } + + /** Check whether the conjunction of all formulas on the stack is unsatisfiable. */ + @Override + public boolean isUnsat() throws SolverException, InterruptedException { + Preconditions.checkState(!closed); + wasLastSatCheckSat = false; + final int result = BitwuzlaJNI.bitwuzla_check_sat(env); + return readSATResult(result); + } + + /** + * Check whether the conjunction of all formulas on the stack together with the list of + * assumptions is satisfiable. + * + * @param assumptions A list of literals. + */ + @Override + public boolean isUnsatWithAssumptions(Collection assumptions) + throws SolverException, InterruptedException { + long[] ass = + assumptions.stream().mapToLong(a -> ((BitwuzlaBooleanFormula) a).getTerm()).toArray(); + final int result = BitwuzlaJNI.bitwuzla_check_sat_assuming(env, assumptions.size(), ass); + return readSATResult(result); + } + + /** + * Get a satisfying assignment. This method should be called only immediately after an {@link + * #isUnsat()} call that returned false. The returned model is guaranteed to stay + * constant and valid as long as the solver context is available, even if constraints are added + * to, pushed or popped from the prover stack. + * + *

A model might contain additional symbols with their evaluation, if a solver uses its own + * temporary symbols. There should be at least a value-assignment for each free symbol. + */ + @Override + public Model getModel() throws SolverException { + Preconditions.checkState(!closed); + Preconditions.checkState(wasLastSatCheckSat, NO_MODEL_HELP); + checkGenerateModels(); + Model result = new CachingModel(getEvaluatorWithoutChecks()); + return result; + } + + private List getUnsatCore0() { + long[] size = new long[1]; + return encapsulate(BitwuzlaJNI.bitwuzla_get_unsat_core(env, size), size[0]); + } + + private List encapsulate(long pTermsArray, long size) { + List result = new ArrayList<>((int) size); + for (int i = 0; i < size; i++) { + result.add(creator.encapsulateBoolean(BitwuzlaJNI.BitwuzlaTermArray_getitem(pTermsArray, i))); + } + return result; + } + + /** + * Get an unsat core. This should be called only immediately after an {@link #isUnsat()} call that + * returned false. + */ + @Override + public List getUnsatCore() { + Preconditions.checkState(!closed); + checkGenerateUnsatCores(); + Preconditions.checkState(!wasLastSatCheckSat); + return getUnsatCore0(); + } + + /** + * Returns an UNSAT core (if it exists, otherwise {@code Optional.empty()}), over the chosen + * assumptions. Does NOT require the {@link ProverOptions#GENERATE_UNSAT_CORE} option to work. + * + * @param assumptions Selected assumptions + * @return Empty optional if the constraints with assumptions are satisfiable, subset of + * assumptions which is unsatisfiable with the original constraints otherwise. + */ + @Override + public Optional> unsatCoreOverAssumptions( + Collection assumptions) throws SolverException, InterruptedException { + Preconditions.checkNotNull(assumptions); + Preconditions.checkState(!closed); + checkGenerateUnsatCores(); + Preconditions.checkState(!wasLastSatCheckSat); + boolean sat = !isUnsatWithAssumptions(assumptions); + return sat ? Optional.empty() : Optional.of(getUnsatCore0()); + } + + /** + * Closes the prover environment. The object should be discarded, and should not be used after + * closing. The first call of this method will close the prover instance, further calls are + * ignored. + */ + @Override + public void close() { + if (!closed) { + BitwuzlaJNI.free_termination(terminationCallbackHelper); + BitwuzlaJNI.bitwuzla_delete(env); + closed = true; + } + super.close(); + } + + @Override + protected BitwuzlaModel getEvaluatorWithoutChecks() { + return new BitwuzlaModel( + env, this, creator, Collections2.transform(getAssertedFormulas(), creator::extractInfo)); + } + + public boolean isClosed() { + return closed; + } + + private long addTerminationCallback() { + Preconditions.checkState(!closed, "solver context is already closed"); + return BitwuzlaJNI.set_termination(env, terminationCallback); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaUFManager.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaUFManager.java new file mode 100644 index 0000000000..af1a685c51 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/BitwuzlaUFManager.java @@ -0,0 +1,18 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +import org.sosy_lab.java_smt.basicimpl.AbstractUFManager; +import org.sosy_lab.java_smt.basicimpl.FormulaCreator; + +public class BitwuzlaUFManager extends AbstractUFManager { + protected BitwuzlaUFManager(FormulaCreator pCreator) { + super(pCreator); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/NumericValue.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/NumericValue.java new file mode 100644 index 0000000000..045aad1e5d --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/NumericValue.java @@ -0,0 +1,77 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package org.sosy_lab.java_smt.solvers.bitwuzla; + +public class NumericValue { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected NumericValue(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(NumericValue obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + BitwuzlaJNI.delete_NumericValue(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setCur(long value) { + BitwuzlaJNI.NumericValue_cur_set(swigCPtr, this, value); + } + + public long getCur() { + return BitwuzlaJNI.NumericValue_cur_get(swigCPtr, this); + } + + public void setDflt(long value) { + BitwuzlaJNI.NumericValue_dflt_set(swigCPtr, this, value); + } + + public long getDflt() { + return BitwuzlaJNI.NumericValue_dflt_get(swigCPtr, this); + } + + public void setMin(long value) { + BitwuzlaJNI.NumericValue_min_set(swigCPtr, this, value); + } + + public long getMin() { + return BitwuzlaJNI.NumericValue_min_get(swigCPtr, this); + } + + public void setMax(long value) { + BitwuzlaJNI.NumericValue_max_set(swigCPtr, this, value); + } + + public long getMax() { + return BitwuzlaJNI.NumericValue_max_get(swigCPtr, this); + } + + public NumericValue() { + this(BitwuzlaJNI.new_NumericValue(), true); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/bitwuzla/package-info.java b/src/org/sosy_lab/java_smt/solvers/bitwuzla/package-info.java new file mode 100644 index 0000000000..2db2c54c78 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/bitwuzla/package-info.java @@ -0,0 +1,14 @@ +// This file is part of JavaSMT, +// an API wrapper for a collection of SMT solvers: +// https://github.com/sosy-lab/java-smt +// +// SPDX-FileCopyrightText: 2023 Dirk Beyer +// +// SPDX-License-Identifier: Apache-2.0 + +/** Interface to the SMT solver Bitwuzla (based on the native C/C++ API and JNI). */ +@com.google.errorprone.annotations.CheckReturnValue +@javax.annotation.ParametersAreNonnullByDefault +@org.sosy_lab.common.annotations.FieldsAreNonnullByDefault +@org.sosy_lab.common.annotations.ReturnValuesAreNonnullByDefault +package org.sosy_lab.java_smt.solvers.bitwuzla; diff --git a/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5FormulaCreator.java b/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5FormulaCreator.java index b5938894ab..d6efa059c9 100644 --- a/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5FormulaCreator.java +++ b/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5FormulaCreator.java @@ -8,105 +8,7 @@ package org.sosy_lab.java_smt.solvers.mathsat5; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_AND; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_ARRAY_READ; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_ARRAY_WRITE; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_ADD; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_AND; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_ASHR; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_CONCAT; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_EXTRACT; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_LSHL; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_LSHR; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_MUL; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_NEG; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_NOT; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_OR; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_SDIV; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_SEXT; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_SLE; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_SLT; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_SREM; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_SUB; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_UDIV; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_ULE; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_ULT; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_UREM; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_XOR; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_BV_ZEXT; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_EQ; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FLOOR; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_ABS; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_ADD; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_AS_IEEEBV; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_CAST; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_DIV; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_EQ; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_FROM_SBV; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_FROM_UBV; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_ISINF; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_ISNAN; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_ISNEG; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_ISNORMAL; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_ISSUBNORMAL; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_ISZERO; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_LE; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_LT; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_MAX; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_MIN; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_MUL; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_NEG; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_ROUND_TO_INT; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_SQRT; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_SUB; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_TO_SBV; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_FP_TO_UBV; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_IFF; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_ITE; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_LEQ; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_NOT; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_OR; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_PLUS; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_TIMES; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_TAG_UNKNOWN; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_decl_get_arg_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_decl_get_name; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_decl_get_tag; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_declare_function; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_array_element_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_array_index_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_array_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_bool_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_bv_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_bv_type_size; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_enum_constants; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_fp_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_fp_type_exp_width; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_fp_type_mant_width; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_function_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_integer_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_rational_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_is_array_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_is_bool_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_is_bv_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_is_enum_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_is_fp_roundingmode_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_is_fp_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_is_integer_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_is_rational_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_constant; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_term; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_arity; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_get_arg; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_get_decl; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_get_type; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_is_constant; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_is_false; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_is_number; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_is_true; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_is_uf; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_repr; -import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_type_repr; +import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.*; import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; @@ -577,7 +479,7 @@ private FloatingPointNumber parseFloatingPoint(String lTermRepresentation) { /** * Returns a range of bits from the bitvector representation of a number. * - * @param start the index of the lowest significant bit to be extracted. + * @param start the index of the lowest significant bit to be extracted. * @param length how many bits to extract? */ private static BigInteger extractBitsFrom(BigInteger number, int start, int length) { diff --git a/src/org/sosy_lab/java_smt/solvers/yices2/Yices2FormulaCreator.java b/src/org/sosy_lab/java_smt/solvers/yices2/Yices2FormulaCreator.java index 3d336c0d80..5bcf3f1ded 100644 --- a/src/org/sosy_lab/java_smt/solvers/yices2/Yices2FormulaCreator.java +++ b/src/org/sosy_lab/java_smt/solvers/yices2/Yices2FormulaCreator.java @@ -8,114 +8,7 @@ package org.sosy_lab.java_smt.solvers.yices2; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_ABS; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_AND; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_APP_TERM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_ARITH_CONST; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_ARITH_GE_ATOM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_ARITH_SUM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BIT_TERM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BOOL_CONST; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_ARRAY; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_ASHR; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_CONST; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_DIV; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_GE_ATOM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_LSHR; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_MUL; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_REM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_SDIV; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_SGE_ATOM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_SHL; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_SMOD; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_SREM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_BV_SUM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_CEIL; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_DISTINCT_TERM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_DIVIDES_ATOM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_EQ_TERM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_FLOOR; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_IDIV; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_IMOD; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_IS_INT_ATOM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_ITE_TERM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_NOT_TERM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_OR_TERM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_POWER_PRODUCT; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_RDIV; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_SELECT_TERM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_UNINTERPRETED_TERM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_VARIABLE; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_XOR_TERM; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_abs; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_and; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_application; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_arith_geq_atom; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bitextract; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bool_const_value; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bool_type; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bv_const_value; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bv_type; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvarray; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvashr; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvconst_from_array; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvdiv; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvge_atom; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvlshr; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvmul; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvpower; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvproduct; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvrem; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvsdiv; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvsge_atom; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvshl; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvsmod; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvsrem; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvsum; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvsum_component; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvtype_size; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_ceil; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_distinct; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_divides_atom; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_division; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_eq; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_floor; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_function_type; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_get_term_name; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_idiv; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_imod; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_int32; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_int_type; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_is_int_atom; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_ite; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_mul; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_named_variable; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_not; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_or; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_parse_rational; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_power; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_product; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_product_component; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_proj_arg; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_proj_index; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_rational_const_value; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_real_type; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_sum; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_sum_component; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_term_bitsize; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_term_child; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_term_constructor; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_term_is_bitvector; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_term_is_bool; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_term_is_int; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_term_is_real; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_term_num_children; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_term_to_string; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_true; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_type_is_bitvector; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_type_of_term; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_type_to_string; -import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_xor; +import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.*; import com.google.common.base.Joiner; import com.google.common.base.Preconditions; diff --git a/src/org/sosy_lab/java_smt/solvers/z3/Z3UserPropagator.java b/src/org/sosy_lab/java_smt/solvers/z3/Z3UserPropagator.java index 591c346b61..9591c40971 100644 --- a/src/org/sosy_lab/java_smt/solvers/z3/Z3UserPropagator.java +++ b/src/org/sosy_lab/java_smt/solvers/z3/Z3UserPropagator.java @@ -65,7 +65,8 @@ protected void finWrapper() { // TODO: This method is not supported for now. @Override - protected void eqWrapper(long pL, long pL1) {} + protected void eqWrapper(long pL, long pL1) { + } @Override protected void fixedWrapper(long lvar, long lvalue) { @@ -85,7 +86,8 @@ protected Z3UserPropagator freshWrapper(long lctx) { // possible) and the solver instantiates the registered function: if the solver // instantiates "forall x: f(x)" at x=y, then f(y) will get created. @Override - protected void createdWrapper(long le) {} + protected void createdWrapper(long le) { + } @Override protected void decideWrapper(long lvar, int bit, boolean isPositive) { diff --git a/src/org/sosy_lab/java_smt/test/BitvectorFormulaManagerTest.java b/src/org/sosy_lab/java_smt/test/BitvectorFormulaManagerTest.java index 0c6d1247f0..850b90c8a5 100644 --- a/src/org/sosy_lab/java_smt/test/BitvectorFormulaManagerTest.java +++ b/src/org/sosy_lab/java_smt/test/BitvectorFormulaManagerTest.java @@ -347,7 +347,7 @@ public void bvIntArray() { assume() .withMessage("Solver %s does not support arrays with integer index", solverToUse()) .that(solverToUse()) - .isNotEqualTo(Solvers.BOOLECTOR); + .isNoneOf(Solvers.BOOLECTOR, Solvers.BITWUZLA); BitvectorFormula bv = bvmgr.makeBitvector(4, 3); ArrayFormula arr = @@ -430,7 +430,7 @@ public void bvIsZeroAfterShiftLeft() throws SolverException, InterruptedExceptio @Test public void bvRotateByConstant() throws SolverException, InterruptedException { - for (int bitsize : new int[] {8, 13, 25, 31}) { + for (int bitsize : new int[]{8, 13, 25, 31}) { BitvectorFormula zero = bvmgr.makeBitvector(bitsize, 0); BitvectorFormula a = bvmgr.makeVariable(bitsize, "a" + bitsize); BitvectorFormula b = bvmgr.makeVariable(bitsize, "b" + bitsize); @@ -448,18 +448,18 @@ public void bvRotateByConstant() throws SolverException, InterruptedException { // rotating twice by half is identity assertThatFormula( - bvmgr.equal(zeroA, bvmgr.rotateLeft(bvmgr.rotateLeft(zeroA, bitsize), bitsize))) + bvmgr.equal(zeroA, bvmgr.rotateLeft(bvmgr.rotateLeft(zeroA, bitsize), bitsize))) .isTautological(); assertThatFormula( - bvmgr.equal(bZero, bvmgr.rotateRight(bvmgr.rotateRight(bZero, bitsize), bitsize))) + bvmgr.equal(bZero, bvmgr.rotateRight(bvmgr.rotateRight(bZero, bitsize), bitsize))) .isTautological(); // rotating a half-zero variable is shifting assertThatFormula( - bvmgr.equal(bvmgr.rotateLeft(zeroA, bitsize), bvmgr.shiftLeft(zeroA, shift))) + bvmgr.equal(bvmgr.rotateLeft(zeroA, bitsize), bvmgr.shiftLeft(zeroA, shift))) .isTautological(); assertThatFormula( - bvmgr.equal(bvmgr.rotateRight(bZero, bitsize), bvmgr.shiftRight(bZero, shift, false))) + bvmgr.equal(bvmgr.rotateRight(bZero, bitsize), bvmgr.shiftRight(bZero, shift, false))) .isTautological(); } } @@ -471,7 +471,7 @@ public void bvRotateByBV() throws SolverException, InterruptedException { .that(solver) .isNotEqualTo(Solvers.PRINCESS); - for (int bitsize : new int[] {8, 13, 25, 31}) { + for (int bitsize : new int[]{8, 13, 25, 31}) { BitvectorFormula zero = bvmgr.makeBitvector(bitsize, 0); BitvectorFormula a = bvmgr.makeVariable(bitsize, "a" + bitsize); BitvectorFormula b = bvmgr.makeVariable(bitsize, "b" + bitsize); @@ -491,23 +491,23 @@ public void bvRotateByBV() throws SolverException, InterruptedException { assertThatFormula(bvmgr.equal(zeroA, bvmgr.rotateLeft(bvmgr.rotateLeft(zeroA, shift), shift))) .isTautological(); assertThatFormula( - bvmgr.equal(bZero, bvmgr.rotateRight(bvmgr.rotateRight(bZero, shift), shift))) + bvmgr.equal(bZero, bvmgr.rotateRight(bvmgr.rotateRight(bZero, shift), shift))) .isTautological(); // rotating a half-zero variable is shifting assertThatFormula(bvmgr.equal(bvmgr.rotateLeft(zeroA, shift), bvmgr.shiftLeft(zeroA, shift))) .isTautological(); assertThatFormula( - bvmgr.equal(bvmgr.rotateRight(bZero, shift), bvmgr.shiftRight(bZero, shift, false))) + bvmgr.equal(bvmgr.rotateRight(bZero, shift), bvmgr.shiftRight(bZero, shift, false))) .isTautological(); } } @Test public void bvIsIdenticalAfterFullRotation() throws SolverException, InterruptedException { - for (int bitsize : new int[] {2, 4, 8, 16, 32, 55}) { + for (int bitsize : new int[]{2, 4, 8, 16, 32, 55}) { BitvectorFormula number = bvmgr.makeVariable(bitsize, "NUM_ROT_" + bitsize); - for (int multiplier : new int[] {0, 1, 2, 5, 17, 37, 111, 1111}) { + for (int multiplier : new int[]{0, 1, 2, 5, 17, 37, 111, 1111}) { int toRotate = multiplier * bitsize; if (toRotate >= (1 << bitsize)) { continue; // ignore numbers larger than bitsize @@ -524,16 +524,16 @@ public void bvInRange() throws SolverException, InterruptedException { requireBitvectors(); assertThatFormula( - bvmgr.equal( - bvmgr.add(bvmgr.makeBitvector(4, 15), bvmgr.makeBitvector(4, -8)), - bvmgr.makeBitvector(4, 7))) + bvmgr.equal( + bvmgr.add(bvmgr.makeBitvector(4, 15), bvmgr.makeBitvector(4, -8)), + bvmgr.makeBitvector(4, 7))) .isTautological(); } @Test @SuppressWarnings("CheckReturnValue") public void bvOutOfRange() { - for (int[] sizeAndValue : new int[][] {{4, 32}, {4, -9}, {8, 300}, {8, -160}}) { + for (int[] sizeAndValue : new int[][]{{4, 32}, {4, -9}, {8, 300}, {8, -160}}) { try { bvmgr.makeBitvector(sizeAndValue[0], sizeAndValue[1]); assert_().fail(); @@ -541,7 +541,7 @@ public void bvOutOfRange() { } } - for (int size : new int[] {4, 6, 8, 10, 16, 32}) { + for (int size : new int[]{4, 6, 8, 10, 16, 32}) { // allowed values bvmgr.makeBitvector(size, (1L << size) - 1); bvmgr.makeBitvector(size, -(1L << (size - 1))); @@ -559,7 +559,7 @@ public void bvOutOfRange() { } } - for (int size : new int[] {36, 40, 64, 65, 100, 128, 200, 250, 1000, 10000}) { + for (int size : new int[]{36, 40, 64, 65, 100, 128, 200, 250, 1000, 10000}) { if (size > 64) { assume() .withMessage("Solver does not support large bitvectors") diff --git a/src/org/sosy_lab/java_smt/test/FloatingPointFormulaManagerTest.java b/src/org/sosy_lab/java_smt/test/FloatingPointFormulaManagerTest.java index cbaba3e2e7..f8d6837751 100644 --- a/src/org/sosy_lab/java_smt/test/FloatingPointFormulaManagerTest.java +++ b/src/org/sosy_lab/java_smt/test/FloatingPointFormulaManagerTest.java @@ -196,8 +196,8 @@ public void fpRemainderNormal() throws SolverException, InterruptedException { .isNotEqualTo(Solvers.MATHSAT5); for (FloatingPointType prec : - new FloatingPointType[] { - singlePrecType, doublePrecType, FormulaType.getFloatingPointType(5, 6), + new FloatingPointType[]{ + singlePrecType, doublePrecType, FormulaType.getFloatingPointType(5, 6), }) { final FloatingPointFormula numFive = fpmgr.makeNumber(5, prec); @@ -220,8 +220,8 @@ public void fpRemainderSpecial() throws SolverException, InterruptedException { .isNotEqualTo(Solvers.MATHSAT5); for (FloatingPointType prec : - new FloatingPointType[] { - singlePrecType, doublePrecType, FormulaType.getFloatingPointType(5, 6), + new FloatingPointType[]{ + singlePrecType, doublePrecType, FormulaType.getFloatingPointType(5, 6), }) { final FloatingPointFormula num = fpmgr.makeNumber(42, prec); @@ -566,6 +566,7 @@ private void assertEqualsAsFormula(FloatingPointFormula f1, FloatingPointFormula @Test public void round() throws SolverException, InterruptedException { + requireIntegers(); // constants round0(0, 0, 0, 0, 0, 0); @@ -952,26 +953,26 @@ public void fpModelValue() throws SolverException, InterruptedException { assertThat(model).isEmpty(); for (float f : - new float[] { - 0, - 1, - 2, - 3, - 4, - 256, - 1000, - 1024, - -1, - -2, - -3, - -4, - -1000, - -1024, - Float.NEGATIVE_INFINITY, - Float.POSITIVE_INFINITY, - Float.MAX_VALUE, - Float.MIN_VALUE, - Float.MIN_NORMAL, + new float[]{ + 0, + 1, + 2, + 3, + 4, + 256, + 1000, + 1024, + -1, + -2, + -3, + -4, + -1000, + -1024, + Float.NEGATIVE_INFINITY, + Float.POSITIVE_INFINITY, + Float.MAX_VALUE, + Float.MIN_VALUE, + Float.MIN_NORMAL, }) { FloatingPointNumber fiveValue = model.evaluate(fpmgr.makeNumber(f, singlePrecType)); assertThat(fiveValue.floatValue()).isEqualTo(f); diff --git a/src/org/sosy_lab/java_smt/test/FloatingPointNumberTest.java b/src/org/sosy_lab/java_smt/test/FloatingPointNumberTest.java index 18d73b1b89..9bb57dfe93 100644 --- a/src/org/sosy_lab/java_smt/test/FloatingPointNumberTest.java +++ b/src/org/sosy_lab/java_smt/test/FloatingPointNumberTest.java @@ -25,26 +25,26 @@ public class FloatingPointNumberTest { @Test public void floatingPointNumberWithSinglePrecision() { for (float f : - new float[] { - 0, - 1, - 2, - 3, - 4, - 256, - 1000, - 1024, - -1, - -2, - -3, - -4, - -1000, - -1024, - Float.NEGATIVE_INFINITY, - Float.POSITIVE_INFINITY, - Float.MAX_VALUE, - Float.MIN_VALUE, - Float.MIN_NORMAL, + new float[]{ + 0, + 1, + 2, + 3, + 4, + 256, + 1000, + 1024, + -1, + -2, + -3, + -4, + -1000, + -1024, + Float.NEGATIVE_INFINITY, + Float.POSITIVE_INFINITY, + Float.MAX_VALUE, + Float.MIN_VALUE, + Float.MIN_NORMAL, }) { var bits = Strings.padStart(Integer.toBinaryString(Float.floatToRawIntBits(f)), 32, '0'); var fpNum = @@ -58,26 +58,26 @@ public void floatingPointNumberWithSinglePrecision() { @Test public void floatingPointNumberWithDoublePrecision() { for (double d : - new double[] { - 0, - 1, - 2, - 3, - 4, - 256, - 1000, - 1024, - -1, - -2, - -3, - -4, - -1000, - -1024, - Double.NEGATIVE_INFINITY, - Double.POSITIVE_INFINITY, - Double.MAX_VALUE, - Double.MIN_VALUE, - Double.MIN_NORMAL, + new double[]{ + 0, + 1, + 2, + 3, + 4, + 256, + 1000, + 1024, + -1, + -2, + -3, + -4, + -1000, + -1024, + Double.NEGATIVE_INFINITY, + Double.POSITIVE_INFINITY, + Double.MAX_VALUE, + Double.MIN_VALUE, + Double.MIN_NORMAL, }) { var bits = Strings.padStart(Long.toBinaryString(Double.doubleToRawLongBits(d)), 64, '0'); var fpNum = diff --git a/src/org/sosy_lab/java_smt/test/FormulaClassifierTest.java b/src/org/sosy_lab/java_smt/test/FormulaClassifierTest.java index 7153a68204..40f0078252 100644 --- a/src/org/sosy_lab/java_smt/test/FormulaClassifierTest.java +++ b/src/org/sosy_lab/java_smt/test/FormulaClassifierTest.java @@ -20,7 +20,10 @@ public class FormulaClassifierTest extends SolverBasedTest0.ParameterizedSolverB private FormulaClassifier classifier; - private static final String VARS = + private static final String BOOL_VARS = + "(declare-fun x () Bool)" + "(declare-fun foo (Bool) Bool)"; + + private static final String NUMERAL_VARS = "(declare-fun x () Int)" + "(declare-fun xx () Int)" + "(declare-fun y () Real)" @@ -30,8 +33,12 @@ public class FormulaClassifierTest extends SolverBasedTest0.ParameterizedSolverB + "(declare-fun foo (Int) Int)" + "(declare-fun bar (Real) Real)"; - private static final String BVS = - "(declare-fun bv () (_ BitVec 4))" + "(declare-fun bv2 () (_ BitVec 4))"; + private static final String BV_VARS = + "(declare-fun bv () (_ BitVec 4))" + + "(declare-fun bv2 () (_ BitVec 4))" + + "(declare-fun bvarr () (Array (_ BitVec 4) (_ BitVec 4)))" + + "(declare-fun bvarr2 () (Array (_ BitVec 4) (_ BitVec 4)))" + + "(declare-fun bvfoo ((_ BitVec 4)) (_ BitVec 4))"; @Before public void init() { @@ -49,8 +56,10 @@ private void requireNonlinear() { @Test public void test_AUFLIA() { requireParser(); + requireArrays(); + requireIntegers(); requireQuantifiers(); // TODO SMTInterpol fails when parsing this - String query = VARS + "(assert (exists ((z Int)) (= (select arr x) (foo z))))"; + String query = NUMERAL_VARS + "(assert (exists ((z Int)) (= (select arr x) (foo z))))"; classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("AUFLIA"); } @@ -58,7 +67,9 @@ public void test_AUFLIA() { @Test public void test_QF_AUFLIA() { requireParser(); - String query = VARS + "(assert (= (select arr x) (foo 0)))"; + requireArrays(); + requireIntegers(); + String query = NUMERAL_VARS + "(assert (= (select arr x) (foo 0)))"; classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_AUFLIA"); } @@ -72,8 +83,10 @@ public void test_QF_AUFLIRA() { .isNotEqualTo(Solvers.OPENSMT); requireParser(); + requireArrays(); + requireIntegers(); requireRationals(); - String query = VARS + "(assert (= (select arr x) (bar (/ 1 2))))"; + String query = NUMERAL_VARS + "(assert (= (select arr x) (bar (/ 1 2))))"; classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_AUFLIRA"); } @@ -81,9 +94,11 @@ public void test_QF_AUFLIRA() { @Test public void test_QF_AUFNIRA() { requireParser(); + requireArrays(); + requireIntegers(); requireRationals(); requireNonlinear(); - String query = VARS + "(assert (= (select arr (* x x)) (bar (/ 1 2))))"; + String query = NUMERAL_VARS + "(assert (= (select arr (* x x)) (bar (/ 1 2))))"; classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_AUFNIRA"); } @@ -91,8 +106,9 @@ public void test_QF_AUFNIRA() { @Test public void test_LIA() { requireParser(); + requireIntegers(); requireQuantifiers(); - String query = VARS + "(assert (exists ((z Int)) (= (+ x 1) 0)))"; + String query = NUMERAL_VARS + "(assert (exists ((z Int)) (= (+ x 1) 0)))"; classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("LIA"); } @@ -100,32 +116,55 @@ public void test_LIA() { @Test public void test_LRA() { requireParser(); + requireRationals(); requireQuantifiers(); requireRationals(); - String query = VARS + "(assert (exists ((zz Real)) (= (+ y y) zz)))"; + String query = NUMERAL_VARS + "(assert (exists ((zz Real)) (= (+ y y) zz)))"; classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("LRA"); } + @Test + public void test_ABVIRA() { + requireParser(); + requireArrays(); + requireQuantifiers(); + requireBitvectors(); + requireIntegers(); + requireRationals(); + assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula + String query = + NUMERAL_VARS + + BV_VARS + + "(assert (and (exists ((bv2 (_ BitVec 4))) (= bv bv2)) (= arr arr2)))"; + classifier.visit(mgr.parse(query)); + assertThat(classifier.toString()).isEqualTo("ABV"); + } + @Test public void test_ABV() { requireParser(); - assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); + requireArrays(); requireQuantifiers(); requireBitvectors(); assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula String query = - VARS + BVS + "(assert (and (exists ((bv2 (_ BitVec 4))) (= bv bv2)) (= arr arr2)))"; + BOOL_VARS + + BV_VARS + + "(assert (and (exists ((bv2 (_ BitVec 4))) (= bv bv2)) (= bvarr " + + "bvarr2)))"; classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("ABV"); } @Test public void test_QF_AUFBV() { + // FIXME: This formula actually uses integers (and reals) and is not in QF_AUFBV" requireParser(); + requireArrays(); requireBitvectors(); assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula - String query = VARS + BVS + "(assert (and (= bv bv2) (= arr arr2) (= (foo x) x)))"; + String query = BV_VARS + "(assert (and (= bv bv2) (= bvarr bvarr2) (= (bvfoo bv) bv2)" + "))"; classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_AUFBV"); } @@ -135,7 +174,7 @@ public void test_QF_BV() { requireParser(); requireBitvectors(); assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula - String query = BVS + "(assert (bvult bv (bvadd bv #x1)))"; + String query = BV_VARS + "(assert (bvult bv (bvadd bv #x1)))"; classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_BV"); } @@ -143,7 +182,8 @@ public void test_QF_BV() { @Test public void test_QF_LIA() { requireParser(); - String query = VARS + "(assert (< xx (* x 2)))"; + requireIntegers(); + String query = NUMERAL_VARS + "(assert (< xx (* x 2)))"; classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_LIA"); } @@ -151,7 +191,8 @@ public void test_QF_LIA() { @Test public void test_QF_LRA() { requireParser(); - String query = VARS + "(assert (< yy y))"; + requireRationals(); + String query = NUMERAL_VARS + "(assert (< yy y))"; assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_LRA"); @@ -160,8 +201,9 @@ public void test_QF_LRA() { @Test public void test_QF_NIA() { requireParser(); + requireIntegers(); requireNonlinear(); - String query = VARS + "(assert (< xx (* x x)))"; + String query = NUMERAL_VARS + "(assert (< xx (* x x)))"; assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_NIA"); @@ -170,36 +212,71 @@ public void test_QF_NIA() { @Test public void test_QF_NRA() { requireParser(); + requireRationals(); requireNonlinear(); - String query = VARS + "(assert (< yy (* y y)))"; + String query = NUMERAL_VARS + "(assert (< yy (* y y)))"; assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_NRA"); } @Test - public void test_QF_UF() { + public void test_QF_UFLIRA() { requireParser(); - String query = VARS + "(assert (= (foo x) x))"; + requireIntegers(); + requireRationals(); // NUMERAL_VARS includes REALs + String query = NUMERAL_VARS + "(assert (= (foo x) x))"; assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_UF"); } + @Test + public void test_QF_UF() { + // FIXME: This formula uses integers/reals and is not in QF_UF + requireParser(); + String query = BOOL_VARS + "(assert (= (foo x) x))"; + assume() + .withMessage("MathSAT does not support functions with Bool arguments") + .that(solverToUse()) + .isNotEqualTo(Solvers.MATHSAT5); + classifier.visit(mgr.parse(query)); + assume() + .that(solverToUse()) + .isNotEqualTo(Solvers.PRINCESS); // Princess classifies it as QF_UFLIA + // TODO: see why Princess classifies this wrongly + assertThat(classifier.toString()).isEqualTo("QF_UF"); + } + + @Test + public void test_QF_UFBVLIRA() { + requireParser(); + requireBitvectors(); + requireRationals(); + requireIntegers(); + assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula + String query = NUMERAL_VARS + BV_VARS + "(assert (and (= bv bv2) (= (foo x) x)))"; + classifier.visit(mgr.parse(query)); + assertThat(classifier.toString()).isEqualTo("QF_UFBV"); + } + @Test public void test_QF_UFBV() { + // FIXME: This formula uses integers/reals and is not in QF_UFBV" requireParser(); requireBitvectors(); assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula - String query = VARS + BVS + "(assert (and (= bv bv2) (= (foo x) x)))"; + String query = BV_VARS + "(assert (and (= bv bv2) (= (bvfoo bv) bv2)))"; classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_UFBV"); } @Test - public void test_QF_UFLIA() { + public void test_QF_UFLIRA2() { requireParser(); - String query = VARS + "(assert (< xx (+ x (foo x))))"; + requireIntegers(); + requireRationals(); // NUMERAL_VARS includes REALs + String query = NUMERAL_VARS + "(assert (< xx (+ x (foo x))))"; assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_UFLIA"); @@ -208,7 +285,8 @@ public void test_QF_UFLIA() { @Test public void test_QF_UFLRA() { requireParser(); - String query = VARS + "(assert (< yy (bar y)))"; + requireRationals(); + String query = NUMERAL_VARS + "(assert (< yy (bar y)))"; assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_UFLRA"); @@ -217,8 +295,9 @@ public void test_QF_UFLRA() { @Test public void test_QF_UFNRA() { requireParser(); + requireRationals(); requireNonlinear(); - String query = VARS + "(assert (< (* y yy) (bar y)))"; + String query = NUMERAL_VARS + "(assert (< (* y yy) (bar y)))"; assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_UFNRA"); @@ -227,8 +306,9 @@ public void test_QF_UFNRA() { @Test public void test_UFLRA() { requireParser(); + requireRationals(); requireQuantifiers(); - String query = VARS + "(assert (exists ((zz Real)) (< (+ y yy) (bar y))))"; + String query = NUMERAL_VARS + "(assert (exists ((zz Real)) (< (+ y yy) (bar y))))"; assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("UFLRA"); @@ -237,8 +317,10 @@ public void test_UFLRA() { @Test public void test_UFNRA() { requireParser(); + requireRationals(); + requireNonlinear(); requireQuantifiers(); // TODO SMTInterpol fails when parsing this - String query = VARS + "(assert (exists ((zz Real)) (< (* y yy) (bar y))))"; + String query = NUMERAL_VARS + "(assert (exists ((zz Real)) (< (* y yy) (bar y))))"; assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("UFNRA"); @@ -248,7 +330,7 @@ public void test_UFNRA() { public void test_QF_FP() { requireParser(); requireFloats(); - String query = VARS + "(declare-fun a () Float32) (assert (fp.eq a (fp.add RNE a a)))"; + String query = "(declare-fun a () Float32) (assert (fp.eq a (fp.add RNE a a)))"; classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("QF_FP"); } @@ -258,7 +340,7 @@ public void test_FP() { requireParser(); requireFloats(); requireQuantifiers(); - String query = VARS + "(declare-fun a () Float32) (assert (exists ((zz Real)) (fp.eq a a)))"; + String query = "(declare-fun a () Float32) (assert (exists ((zz Float32)) (fp.eq a a)))"; classifier.visit(mgr.parse(query)); assertThat(classifier.toString()).isEqualTo("FP"); } diff --git a/src/org/sosy_lab/java_smt/test/FormulaManagerTest.java b/src/org/sosy_lab/java_smt/test/FormulaManagerTest.java index fffdcb36e7..d570930d7f 100644 --- a/src/org/sosy_lab/java_smt/test/FormulaManagerTest.java +++ b/src/org/sosy_lab/java_smt/test/FormulaManagerTest.java @@ -34,6 +34,7 @@ public class FormulaManagerTest extends SolverBasedTest0.ParameterizedSolverBase @Test public void testEmptySubstitution() throws SolverException, InterruptedException { requireSubstitution(); + requireIntegers(); assume().withMessage("Princess fails").that(solver).isNotEqualTo(Solvers.PRINCESS); IntegerFormula variable1 = imgr.makeVariable("variable1"); @@ -54,6 +55,7 @@ public void testEmptySubstitution() throws SolverException, InterruptedException @Test public void testNoSubstitution() throws SolverException, InterruptedException { requireSubstitution(); + requireIntegers(); assume().withMessage("Princess fails").that(solver).isNotEqualTo(Solvers.PRINCESS); IntegerFormula variable1 = imgr.makeVariable("variable1"); @@ -172,7 +174,7 @@ public void testSubstitutionSelfReference() throws SolverException, InterruptedE @Test public void formulaEqualsAndHashCode() { // Solvers without integers (Boolector) get their own test below - assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); + requireIntegers(); FunctionDeclaration fb = fmgr.declareUF("f_b", IntegerType, IntegerType); new EqualsTester() @@ -226,28 +228,28 @@ public void bitvectorFormulaEqualsAndHashCode() { FormulaType.getBitvectorTypeWithSize(8)); new EqualsTester() - .addEqualityGroup(bmgr.makeBoolean(true)) - .addEqualityGroup(bmgr.makeBoolean(false)) - .addEqualityGroup(bmgr.makeVariable("bool_a")) - .addEqualityGroup(bvmgr.makeVariable(8, "bv_a")) + .addEqualityGroup(bmgr.makeBoolean(true)) // 0 + .addEqualityGroup(bmgr.makeBoolean(false)) // 1 + .addEqualityGroup(bmgr.makeVariable("bool_a")) // 2 + .addEqualityGroup(bvmgr.makeVariable(8, "bv_a")) // 3 // Way of creating numbers should not make a difference. .addEqualityGroup( bvmgr.makeBitvector(8, 0L), bvmgr.makeBitvector(8, 0), - bvmgr.makeBitvector(8, BigInteger.ZERO)) + bvmgr.makeBitvector(8, BigInteger.ZERO)) // 4 .addEqualityGroup( bvmgr.makeBitvector(8, 1L), bvmgr.makeBitvector(8, 1), - bvmgr.makeBitvector(8, BigInteger.ONE)) + bvmgr.makeBitvector(8, BigInteger.ONE)) // 5 // The same formula when created twice should compare equal. - .addEqualityGroup(bmgr.makeVariable("bool_b"), bmgr.makeVariable("bool_b")) + .addEqualityGroup(bmgr.makeVariable("bool_b"), bmgr.makeVariable("bool_b")) // 6 .addEqualityGroup( bmgr.and(bmgr.makeVariable("bool_a"), bmgr.makeVariable("bool_b")), - bmgr.and(bmgr.makeVariable("bool_a"), bmgr.makeVariable("bool_b"))) + bmgr.and(bmgr.makeVariable("bool_a"), bmgr.makeVariable("bool_b"))) // 7 .addEqualityGroup( bvmgr.equal(bvmgr.makeBitvector(8, 0), bvmgr.makeVariable(8, "int_a")), - bvmgr.equal(bvmgr.makeBitvector(8, 0), bvmgr.makeVariable(8, "int_a"))) + bvmgr.equal(bvmgr.makeBitvector(8, 0), bvmgr.makeVariable(8, "int_a"))) // 8 // UninterpretedFunctionDeclarations should not compare equal to Formulas, // but declaring one twice needs to return the same UIF. @@ -259,8 +261,8 @@ public void bitvectorFormulaEqualsAndHashCode() { fmgr.declareUF( "f_a", FormulaType.getBitvectorTypeWithSize(8), - FormulaType.getBitvectorTypeWithSize(8))) - .addEqualityGroup(fb) + FormulaType.getBitvectorTypeWithSize(8))) // 9 + .addEqualityGroup(fb) // 10 .addEqualityGroup(fmgr.callUF(fb, bvmgr.makeBitvector(8, 0))) .addEqualityGroup( fmgr.callUF(fb, bvmgr.makeBitvector(8, 1)), // why not equal?! diff --git a/src/org/sosy_lab/java_smt/test/ModelTest.java b/src/org/sosy_lab/java_smt/test/ModelTest.java index f1622b109b..0debb9113d 100644 --- a/src/org/sosy_lab/java_smt/test/ModelTest.java +++ b/src/org/sosy_lab/java_smt/test/ModelTest.java @@ -828,15 +828,15 @@ public void testPartialModels2() throws SolverException, InterruptedException { prover.push(bvmgr.greaterThan(x, bvmgr.makeBitvector(8, 0), true)); assertThat(prover).isSatisfiable(); try (Model m = prover.getModel()) { - if (solver != Solvers.BOOLECTOR) { + if (solver != Solvers.BOOLECTOR && solver != Solvers.BITWUZLA) { assertThat(m.evaluate(x)).isEqualTo(BigInteger.ONE); } else { assertThat(m.evaluate(x)).isEqualTo(BigInteger.valueOf(64)); } // it works now, but maybe the model "x=1" for the constraint "x>0" is not valid for new // solvers. - // Can confirm ;D Boolector likes to take the "max" values for bitvectors instead of the - // min; as a result it returns 64 + // Can confirm ;D Boolector/Bitwuzla like to take the "max" values for bitvectors + // instead of the min; as a result it returns 64 } } } @@ -1111,6 +1111,7 @@ public void testGetArrays2() throws SolverException, InterruptedException { @Test public void testGetArrays6() throws SolverException, InterruptedException { requireArrays(); + requireIntegers(); requireArrayModel(); requireParser(); @@ -1138,6 +1139,7 @@ public void testGetArrays6() throws SolverException, InterruptedException { @Test public void testGetArrays3() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); requireArrays(); requireArrayModel(); @@ -1180,6 +1182,7 @@ public void testGetArrays3() throws SolverException, InterruptedException { @Test public void testGetArrays4() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); requireArrays(); requireArrayModel(); @@ -1234,6 +1237,7 @@ public void testGetArrays4invalid() throws SolverException, InterruptedException @Test public void testGetArrays5() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); requireArrays(); requireArrayModel(); @@ -1261,6 +1265,7 @@ public void testGetArrays5() throws SolverException, InterruptedException { @Test public void testGetArrays5b() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); requireArrays(); requireArrayModel(); @@ -1316,6 +1321,7 @@ public void testGetArrays5b() throws SolverException, InterruptedException { @Test public void testGetArrays5c() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); requireArrays(); requireArrayModel(); @@ -1352,6 +1358,7 @@ public void testGetArrays5c() throws SolverException, InterruptedException { @Test public void testGetArrays5d() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); requireArrays(); requireArrayModel(); @@ -1388,6 +1395,7 @@ public void testGetArrays5d() throws SolverException, InterruptedException { @Test public void testGetArrays5e() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); requireArrays(); requireArrayModel(); @@ -1424,6 +1432,7 @@ public void testGetArrays5e() throws SolverException, InterruptedException { @Test public void testGetArrays5f() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); requireArrays(); requireArrayModel(); @@ -1790,14 +1799,14 @@ private void checkModelIteration(BooleanFormula f, boolean useOptProver) assertThatFormula(va.getAssignmentAsFormula()) .isEqualTo(makeAssignment(va.getKey(), va.getValueAsFormula())); assertThat( - ImmutableList.of( - Boolean.class, - BigInteger.class, - Rational.class, - Double.class, - FloatingPointNumber.class) - .stream() - .anyMatch(cls -> cls.isInstance(va.getValue()))) + ImmutableList.of( + Boolean.class, + BigInteger.class, + Rational.class, + Double.class, + FloatingPointNumber.class) + .stream() + .anyMatch(cls -> cls.isInstance(va.getValue()))) .isTrue(); } @@ -2139,6 +2148,7 @@ public void quantifierTestShort() throws SolverException, InterruptedException { @Test public void arrayTest1() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); requireArrays(); requireArrayModel(); @@ -2156,6 +2166,7 @@ public void arrayTest2() throws SolverException, InterruptedException { requireArrays(); requireArrayModel(); requireOptimization(); + requireIntegers(); requireFloats(); requireBitvectors(); // only Z3 fulfills these requirements @@ -2193,6 +2204,7 @@ public void arrayTest2() throws SolverException, InterruptedException { @Test public void arrayTest3() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); requireArrays(); requireArrayModel(); @@ -2204,6 +2216,7 @@ public void arrayTest3() throws SolverException, InterruptedException { public void arrayTest4() throws SolverException, InterruptedException { requireParser(); requireArrays(); + requireIntegers(); requireBitvectors(); BooleanFormula formula = context.getFormulaManager().parse(ARRAY_QUERY_BV); checkModelIteration(formula, false); diff --git a/src/org/sosy_lab/java_smt/test/PrettyPrinterTest.java b/src/org/sosy_lab/java_smt/test/PrettyPrinterTest.java index dbfd48d8ea..0898dec9c8 100644 --- a/src/org/sosy_lab/java_smt/test/PrettyPrinterTest.java +++ b/src/org/sosy_lab/java_smt/test/PrettyPrinterTest.java @@ -36,9 +36,16 @@ public void init() { pp = new PrettyPrinter(context.getFormulaManager()); } + // TODO: Bitwuzla + // Add parsing tests for bitvectors and booleans that can be used with Bitwuzla + @Test public void testPrettyPrintOnlyBoolean() { requireParser(); + requireIntegers(); + requireRationals(); + requireArrays(); + String expected; switch (solverToUse()) { case MATHSAT5: @@ -79,6 +86,10 @@ public void testPrettyPrintOnlyBoolean() { @Test public void testPrettyPrintAll() { requireParser(); + requireIntegers(); + requireRationals(); + requireArrays(); + String expected; switch (solverToUse()) { case MATHSAT5: @@ -178,6 +189,10 @@ public void testPrettyPrintAll() { @Test public void testDotOnlyBoolean() { requireParser(); + requireIntegers(); + requireRationals(); + requireArrays(); + String expected; switch (solverToUse()) { case MATHSAT5: @@ -258,6 +273,10 @@ public void testDotOnlyBoolean() { @Test public void testDotAll() { requireParser(); + requireIntegers(); + requireRationals(); + requireArrays(); + String expected; switch (solverToUse()) { case MATHSAT5: diff --git a/src/org/sosy_lab/java_smt/test/ProverEnvironmentTest.java b/src/org/sosy_lab/java_smt/test/ProverEnvironmentTest.java index 5380e5d4b3..5da730e74a 100644 --- a/src/org/sosy_lab/java_smt/test/ProverEnvironmentTest.java +++ b/src/org/sosy_lab/java_smt/test/ProverEnvironmentTest.java @@ -100,6 +100,7 @@ public void unsatCoreTestForOptimizationProver() throws SolverException, Interru private void unsatCoreTest0(BasicProverEnvironment pe) throws InterruptedException, SolverException { + requireIntegers(); pe.push(); pe.addConstraint(imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(1))); pe.addConstraint(imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(2))); @@ -129,6 +130,7 @@ public void unsatCoreWithAssumptionsNullTest() { @Test public void unsatCoreWithAssumptionsTest() throws SolverException, InterruptedException { + requireIntegers(); requireUnsatCore(); assume() .withMessage( @@ -158,12 +160,13 @@ public void testSatWithUnsatUnsatCoreOptions() throws InterruptedException, Solv requireUnsatCoreOverAssumptions(); try (ProverEnvironment prover = - context.newProverEnvironment(GENERATE_UNSAT_CORE_OVER_ASSUMPTIONS)) { + context.newProverEnvironment(GENERATE_UNSAT_CORE_OVER_ASSUMPTIONS)) { checkSimpleQuery(prover); } try (ProverEnvironment prover = - context.newProverEnvironment(GENERATE_UNSAT_CORE, GENERATE_UNSAT_CORE_OVER_ASSUMPTIONS)) { + context.newProverEnvironment(GENERATE_UNSAT_CORE, + GENERATE_UNSAT_CORE_OVER_ASSUMPTIONS)) { checkSimpleQuery(prover); } } diff --git a/src/org/sosy_lab/java_smt/test/QuantifierManagerTest.java b/src/org/sosy_lab/java_smt/test/QuantifierManagerTest.java index 293ebdbfbc..67a8c27f1f 100644 --- a/src/org/sosy_lab/java_smt/test/QuantifierManagerTest.java +++ b/src/org/sosy_lab/java_smt/test/QuantifierManagerTest.java @@ -66,40 +66,42 @@ public class QuantifierManagerTest extends SolverBasedTest0.ParameterizedSolverB @Before public void setUpLIA() { - requireIntegers(); requireArrays(); requireQuantifiers(); - x = imgr.makeVariable("x"); - a = amgr.makeArray("a", FormulaType.IntegerType, FormulaType.IntegerType); + if (imgr != null) { + x = imgr.makeVariable("x"); + a = amgr.makeArray("a", FormulaType.IntegerType, FormulaType.IntegerType); - a_at_x_eq_1 = imgr.equal(amgr.select(a, x), imgr.makeNumber(1)); - a_at_x_eq_0 = imgr.equal(amgr.select(a, x), imgr.makeNumber(0)); + a_at_x_eq_1 = imgr.equal(amgr.select(a, x), imgr.makeNumber(1)); + a_at_x_eq_0 = imgr.equal(amgr.select(a, x), imgr.makeNumber(0)); - forall_x_a_at_x_eq_0 = qmgr.forall(ImmutableList.of(x), a_at_x_eq_0); + forall_x_a_at_x_eq_0 = qmgr.forall(ImmutableList.of(x), a_at_x_eq_0); + } } @Before public void setUpBV() { - requireBitvectors(); requireArrays(); requireQuantifiers(); - assume() - .withMessage("Solver %s does not support quantifiers via JavaSMT", solverToUse()) - .that(solverToUse()) - .isNotEqualTo(Solvers.BOOLECTOR); - - xbv = bvmgr.makeVariable(bvWidth, "xbv"); - bvArray = - amgr.makeArray( - "bvArray", - FormulaType.getBitvectorTypeWithSize(bvWidth), - FormulaType.getBitvectorTypeWithSize(bvWidth)); - - bvArray_at_x_eq_1 = bvmgr.equal(amgr.select(bvArray, xbv), bvmgr.makeBitvector(bvWidth, 1)); - bvArray_at_x_eq_0 = bvmgr.equal(amgr.select(bvArray, xbv), bvmgr.makeBitvector(bvWidth, 0)); - - bv_forall_x_a_at_x_eq_0 = qmgr.forall(ImmutableList.of(xbv), bvArray_at_x_eq_0); + if (bmgr != null) { + assume() + .withMessage("Solver %s does not support quantifiers via JavaSMT", solverToUse()) + .that(solverToUse()) + .isNotEqualTo(Solvers.BOOLECTOR); + + xbv = bvmgr.makeVariable(bvWidth, "xbv"); + bvArray = + amgr.makeArray( + "bvArray", + FormulaType.getBitvectorTypeWithSize(bvWidth), + FormulaType.getBitvectorTypeWithSize(bvWidth)); + + bvArray_at_x_eq_1 = bvmgr.equal(amgr.select(bvArray, xbv), bvmgr.makeBitvector(bvWidth, 1)); + bvArray_at_x_eq_0 = bvmgr.equal(amgr.select(bvArray, xbv), bvmgr.makeBitvector(bvWidth, 0)); + + bv_forall_x_a_at_x_eq_0 = qmgr.forall(ImmutableList.of(xbv), bvArray_at_x_eq_0); + } } private SolverException handleSolverException(SolverException e) throws SolverException { @@ -368,7 +370,7 @@ public void testBVExistsArrayConjunct1() throws SolverException, InterruptedExce BooleanFormula f = bmgr.and( - qmgr.exists(ImmutableList.of(x), a_at_x_eq_0), + qmgr.exists(ImmutableList.of(xbv), bvArray_at_x_eq_0), bvmgr.equal( amgr.select(bvArray, bvmgr.makeBitvector(bvWidth, 123)), bvmgr.makeBitvector(bvWidth, 1))); @@ -383,7 +385,6 @@ public void testLIAExistsArrayConjunct2() throws SolverException, InterruptedExc .isNotEqualTo(Solvers.CVC5); // (exists x . b[x] = 1) AND (forall x . b[x] = 0) is UNSAT - requireIntegers(); BooleanFormula f = bmgr.and(qmgr.exists(ImmutableList.of(x), a_at_x_eq_1), forall_x_a_at_x_eq_0); @@ -453,7 +454,6 @@ public void testBVExistsArrayConjunct3() throws SolverException, InterruptedExce @Test public void testLIAExistsArrayDisjunct1() throws SolverException, InterruptedException { // (exists x . b[x] = 0) OR (forall x . b[x] = 1) is SAT - requireIntegers(); BooleanFormula f = bmgr.or( @@ -486,7 +486,6 @@ public void testBVExistsArrayDisjunct1() throws SolverException, InterruptedExce @Test public void testLIAExistsArrayDisjunct2() throws SolverException, InterruptedException { // (exists x . b[x] = 1) OR (exists x . b[x] = 1) is SAT - requireIntegers(); BooleanFormula f = bmgr.or( @@ -514,7 +513,6 @@ public void testBVExistsArrayDisjunct2() throws SolverException, InterruptedExce @Test public void testLIAContradiction() throws SolverException, InterruptedException { // forall x . x = x+1 is UNSAT - requireIntegers(); BooleanFormula f = qmgr.forall(ImmutableList.of(x), imgr.equal(x, imgr.add(x, imgr.makeNumber(1)))); @@ -807,6 +805,10 @@ public void checkBVQuantifierEliminationFail() throws InterruptedException, Solv .withMessage("Solver %s does not support the complete theory of quantifiers", solverToUse()) .that(solverToUse()) .isNoneOf(Solvers.CVC5, Solvers.BOOLECTOR, Solvers.PRINCESS); + assume() + .withMessage("Bitwuzla does not support quantifier elimination.") + .that(solverToUse()) + .isNotEqualTo(Solvers.BITWUZLA); int width = 2; BitvectorFormula xx = bvmgr.makeVariable(width, "x_bv"); @@ -829,6 +831,10 @@ public void checkBVQuantifierEliminationFail() throws InterruptedException, Solv @Test public void checkBVQuantifierElimination() throws InterruptedException, SolverException { requireBitvectors(); + assume() + .withMessage("Bitwuzla does not support quantifier elimination.") + .that(solverToUse()) + .isNotEqualTo(Solvers.BITWUZLA); // build formula: exists y : bv[2]. x * y = 1 // quantifier-free equivalent: x = 1 | x = 3 @@ -853,6 +859,10 @@ public void checkBVQuantifierElimination() throws InterruptedException, SolverEx @Test public void checkBVQuantifierElimination2() throws InterruptedException, SolverException { requireBitvectors(); + assume() + .withMessage("Bitwuzla does not support quantifier elimination.") + .that(solverToUse()) + .isNotEqualTo(Solvers.BITWUZLA); // build formula: exists a2 : (and (= a2 #x00000006) // (= b2 #x00000006) @@ -888,6 +898,7 @@ public void checkBVQuantifierElimination2() throws InterruptedException, SolverE @Test public void testExistsRestrictedRange() throws SolverException, InterruptedException { + requireIntegers(); assume() .withMessage("Solver %s does not support the complete theory of quantifiers", solverToUse()) .that(solverToUse()) @@ -921,6 +932,7 @@ public void testExistsRestrictedRange() throws SolverException, InterruptedExcep @Test public void testExistsRestrictedRangeWithoutInconclusiveSolvers() throws SolverException, InterruptedException { + requireIntegers(); assume() .withMessage("Solver %s does not support the complete theory of quantifiers", solverToUse()) .that(solverToUse()) @@ -944,6 +956,7 @@ public void testExistsRestrictedRangeWithoutInconclusiveSolvers() @Test public void testForallRestrictedRange() throws SolverException, InterruptedException { + requireIntegers(); assume() .withMessage("Solver %s does not support the complete theory of quantifiers", solverToUse()) .that(solverToUse()) @@ -978,6 +991,7 @@ public void testForallRestrictedRange() throws SolverException, InterruptedExcep @Test public void testForallRestrictedRangeWithoutConclusiveSolvers() throws SolverException, InterruptedException { + requireIntegers(); assume() .withMessage("Solver %s does not support the complete theory of quantifiers", solverToUse()) .that(solverToUse()) diff --git a/src/org/sosy_lab/java_smt/test/SolverBasedTest0.java b/src/org/sosy_lab/java_smt/test/SolverBasedTest0.java index d57494e017..66e47bd00d 100644 --- a/src/org/sosy_lab/java_smt/test/SolverBasedTest0.java +++ b/src/org/sosy_lab/java_smt/test/SolverBasedTest0.java @@ -250,6 +250,14 @@ protected final void requireQuantifiers() { } protected final void requireFloats() { + // TODO: Bitwuza + // Remove once we have a proper solution to the results + assume() + .withMessage( + "FP is not available in Bitwuzla until we can get a proper decimal " + + "representation of the results.") + .that(solverToUse()) + .isNotEqualTo(Solvers.BITWUZLA); assume() .withMessage("Solver %s does not support the theory of floats", solverToUse()) .that(fpmgr) diff --git a/src/org/sosy_lab/java_smt/test/SolverConcurrencyTest.java b/src/org/sosy_lab/java_smt/test/SolverConcurrencyTest.java index ea3bae1d36..3d494fbe55 100644 --- a/src/org/sosy_lab/java_smt/test/SolverConcurrencyTest.java +++ b/src/org/sosy_lab/java_smt/test/SolverConcurrencyTest.java @@ -141,7 +141,7 @@ private void requireIntegers() { assume() .withMessage("Solver does not support integers") .that(solver) - .isNoneOf(Solvers.BOOLECTOR, Solvers.YICES2); + .isNoneOf(Solvers.BOOLECTOR, Solvers.YICES2, Solvers.BITWUZLA); } private void requireBitvectors() { @@ -162,6 +162,7 @@ private void requireOptimization() { Solvers.CVC4, Solvers.CVC5, Solvers.YICES2, + Solvers.BITWUZLA, Solvers.OPENSMT); } @@ -197,6 +198,74 @@ public void testBvConcurrencyWithConcurrentContext() { }); } + /** + * Create 1 context and all managers + some basic formulas (e.g. true, false). Then, test basic + * checks (isFalse(), isTrue()) und usage of these managers in a different thread. This failed for + * a solver in the past, even when all other tests in this class worked! + */ + @Test + public void testConcurrencyWithConcurrentManagers() throws InvalidConfigurationException { + assume() + .withMessage( + "Solver does not support usage of managers in threads distinct to the " + + "creating thread") + .that(solver) + .isNotEqualTo(Solvers.BITWUZLA); + + ConcurrentLinkedQueue contextAndFormulaList = new ConcurrentLinkedQueue<>(); + SolverContext context = initSolver(); + FormulaManager mgr = context.getFormulaManager(); + BooleanFormulaManager bmgr = mgr.getBooleanFormulaManager(); + BooleanFormula tru = bmgr.makeTrue(); + BooleanFormula fls = bmgr.makeFalse(); + contextAndFormulaList.add(new ContextAndFormula(context, tru)); + contextAndFormulaList.add(new ContextAndFormula(context, fls)); + BooleanFormula var = bmgr.makeVariable("var"); + BooleanFormula trueFormula = bmgr.not(bmgr.and(var, bmgr.not(var))); + BooleanFormula falseFormula = bmgr.and(var, bmgr.not(var)); + contextAndFormulaList.add(new ContextAndFormula(context, trueFormula)); + contextAndFormulaList.add(new ContextAndFormula(context, falseFormula)); + // Check that its correctly true/false in the manager + checkBooleanFormulas(bmgr, tru, fls, trueFormula, falseFormula); + + assertConcurrency( + "testManagerUsageInDifferentThreads", + () -> { + ContextAndFormula[] ctxAndFormulas = + contextAndFormulaList.toArray(new ContextAndFormula[0]); + SolverContext threadContext = ctxAndFormulas[0].getContext(); + FormulaManager threadMgr = threadContext.getFormulaManager(); + BooleanFormulaManager threadBmgr = threadMgr.getBooleanFormulaManager(); + BooleanFormula threadTrue = ctxAndFormulas[0].getFormula(); + BooleanFormula threadFalse = ctxAndFormulas[1].getFormula(); + BooleanFormula threadTrueFormula = ctxAndFormulas[2].getFormula(); + BooleanFormula threadFalseFormula = ctxAndFormulas[3].getFormula(); + + checkBooleanFormulas( + threadBmgr, threadTrue, threadFalse, threadTrueFormula, threadFalseFormula); + }); + } + + /* + * Check the entered BooleanFormulas in the BooleanFormulaManager for true/false. + */ + private void checkBooleanFormulas( + BooleanFormulaManager pBmgr, + BooleanFormula pTru, + BooleanFormula pFls, + BooleanFormula pTrueFormula, + BooleanFormula pFalseFormula) { + assertThat(pBmgr.isFalse(pTru)).isFalse(); + assertThat(pBmgr.isTrue(pTru)).isTrue(); + + assertThat(pBmgr.isFalse(pFls)).isTrue(); + assertThat(pBmgr.isTrue(pFls)).isFalse(); + + assertThat(pBmgr.isFalse(pTrueFormula)).isFalse(); + + assertThat(pBmgr.isTrue(pFalseFormula)).isFalse(); + } + /** Helperclass to pack a SolverContext together with a Formula. */ private static class ContextAndFormula { private final SolverContext context; @@ -309,7 +378,7 @@ public void testBvConcurrencyWithoutConcurrentContext() throws InvalidConfigurat assume() .withMessage("Solver does not support concurrency without concurrent context.") .that(solver) - .isNotEqualTo(Solvers.CVC5); + .isNoneOf(Solvers.CVC5, Solvers.BITWUZLA); ConcurrentLinkedQueue contextList = new ConcurrentLinkedQueue<>(); // Initialize contexts before using them in the threads @@ -349,6 +418,7 @@ public void testConcurrentOptimization() { */ @Test public void testConcurrentStack() throws InvalidConfigurationException, InterruptedException { + requireIntegers(); requireConcurrentMultipleStackSupport(); SolverContext context = initSolver(); FormulaManager mgr = context.getFormulaManager(); diff --git a/src/org/sosy_lab/java_smt/test/SolverContextFactoryTest.java b/src/org/sosy_lab/java_smt/test/SolverContextFactoryTest.java index c145b1b181..9579196a89 100644 --- a/src/org/sosy_lab/java_smt/test/SolverContextFactoryTest.java +++ b/src/org/sosy_lab/java_smt/test/SolverContextFactoryTest.java @@ -97,6 +97,10 @@ private void requireSupportedOperatingSystem() { case YICES2: assume.that(IS_LINUX).isTrue(); return; + case BITWUZLA: + assume.that(IS_LINUX).isTrue(); + assume.that(isSufficientVersionOfLibc()).isTrue(); + return; case MATHSAT5: assume.that(IS_LINUX || IS_WINDOWS).isTrue(); return; @@ -126,6 +130,18 @@ private boolean isSufficientVersionOfLibcxx() { return true; } + /** Bitwuzla requires GLIB version 2.20 or newer. This is not included in Ubuntu 18.04. */ + private boolean isSufficientVersionOfLibc() { + try { + NativeLibraries.loadLibrary("bitwuzla"); + } catch (UnsatisfiedLinkError e) { + if (e.getMessage().contains("version `GLIBC_2.29' not found")) { + return false; + } + } + return true; + } + @Before public final void initSolver() throws InvalidConfigurationException { config = Configuration.builder().setOption("solver.solver", solverToUse().toString()).build(); diff --git a/src/org/sosy_lab/java_smt/test/SolverFormulaIODeclarationsTest.java b/src/org/sosy_lab/java_smt/test/SolverFormulaIODeclarationsTest.java index d8f896f6b9..07108a75fe 100644 --- a/src/org/sosy_lab/java_smt/test/SolverFormulaIODeclarationsTest.java +++ b/src/org/sosy_lab/java_smt/test/SolverFormulaIODeclarationsTest.java @@ -9,6 +9,7 @@ package org.sosy_lab.java_smt.test; import static com.google.common.truth.Truth.assert_; +import static com.google.common.truth.TruthJUnit.assume; import static org.junit.Assert.assertThrows; import static org.sosy_lab.java_smt.api.FormulaType.BooleanType; import static org.sosy_lab.java_smt.api.FormulaType.IntegerType; @@ -18,6 +19,7 @@ import org.junit.Before; import org.junit.Test; import org.sosy_lab.java_smt.SolverContextFactory.Solvers; +import org.sosy_lab.java_smt.api.BitvectorFormula; import org.sosy_lab.java_smt.api.BooleanFormula; import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula; import org.sosy_lab.java_smt.api.SolverException; @@ -39,6 +41,7 @@ public void parseDeclareInQueryTest1() { @Test public void parseDeclareInQueryTest2() { + requireIntegers(); String query = "(declare-fun x () Int)(assert (= 0 x))"; BooleanFormula formula = mgr.parse(query); Truth.assertThat(mgr.extractVariables(formula)).hasSize(1); @@ -46,6 +49,7 @@ public void parseDeclareInQueryTest2() { @Test public void parseDeclareInQueryTest3() { + requireIntegers(); String query = "(declare-fun foo (Int Int) Bool)(assert (foo 1 2))"; BooleanFormula formula = mgr.parse(query); Truth.assertThat(mgr.extractVariablesAndUFs(formula)).hasSize(1); @@ -53,6 +57,7 @@ public void parseDeclareInQueryTest3() { @Test public void parseDeclareInQueryTest4() { + requireIntegers(); String query = "(declare-fun x () Int)(declare-fun foo (Int Int) Bool)(assert (foo x 2))"; BooleanFormula formula = mgr.parse(query); Truth.assertThat(mgr.extractVariablesAndUFs(formula)).hasSize(2); @@ -63,11 +68,15 @@ public void parseDeclareAfterQueryTest1() { String query = "(declare-fun var () Bool)(assert var)"; BooleanFormula formula = mgr.parse(query); BooleanFormula var = bmgr.makeVariable("var"); + assume().that(solverToUse()).isNotEqualTo(Solvers.BITWUZLA); + // Bitwuzla returns 2 distinct variables + // TODO: investigate and fix Truth.assertThat(mgr.extractVariables(formula).values()).containsExactly(var); } @Test public void parseDeclareAfterQueryTest2() { + requireIntegers(); String query = "(declare-fun x () Int)(assert (= 0 x))"; BooleanFormula formula = mgr.parse(query); IntegerFormula var = imgr.makeVariable("x"); @@ -76,6 +85,7 @@ public void parseDeclareAfterQueryTest2() { @Test public void parseDeclareAfterQueryTest3() { + requireIntegers(); String query = "(declare-fun foo (Int Int) Bool)(assert (foo 1 2))"; BooleanFormula formula = mgr.parse(query); BooleanFormula calledFoo = @@ -85,6 +95,7 @@ public void parseDeclareAfterQueryTest3() { @Test public void parseDeclareAfterQueryTest4() { + requireIntegers(); String query = "(declare-fun x () Int)(declare-fun foo (Int Int) Bool)(assert (foo 1 x))"; BooleanFormula formula = mgr.parse(query); IntegerFormula var = imgr.makeVariable("x"); @@ -118,6 +129,9 @@ public void parseDeclareNeverTest4() { @Test public void parseDeclareBeforeTest() { + assume().that(solverToUse()).isNotEqualTo(Solvers.BITWUZLA); + // Bitwuzla just throws an error for this case + // TODO: investigate and report to the devs String query = "(assert var)"; BooleanFormula var = bmgr.makeVariable("var"); BooleanFormula formula = mgr.parse(query); @@ -126,6 +140,7 @@ public void parseDeclareBeforeTest() { @Test public void parseDeclareRedundantTest1() { + requireIntegers(); IntegerFormula var = imgr.makeVariable("x"); String query = "(declare-fun x () Int)(declare-fun x () Int)(assert (= 0 x))"; if (EnumSet.of(Solvers.PRINCESS, Solvers.Z3).contains(solverToUse())) { @@ -139,6 +154,7 @@ public void parseDeclareRedundantTest1() { @Test public void parseDeclareRedundantTest2() { + requireIntegers(); IntegerFormula var = fmgr.declareAndCallUF("foo", IntegerType, imgr.makeNumber(1), imgr.makeNumber(2)); String query = @@ -154,12 +170,14 @@ public void parseDeclareRedundantTest2() { @Test public void parseDeclareConflictInQueryTest1() { + requireIntegers(); String query = "(declare-fun x () Bool)(declare-fun x () Int)(assert (= 0 x))"; assertThrows(IllegalArgumentException.class, () -> mgr.parse(query)); } @Test public void parseDeclareConflictInQueryTest2() { + requireIntegers(); String query = "(declare-fun x () Bool)(declare-fun x (Int Int) Bool)(assert (x 2 3))"; if (Solvers.Z3 != solverToUse()) { assertThrows(IllegalArgumentException.class, () -> mgr.parse(query)); @@ -168,6 +186,7 @@ public void parseDeclareConflictInQueryTest2() { @Test public void parseDeclareConflictInQueryTest3() { + requireIntegers(); String query = "(declare-fun x (Int) Bool)(declare-fun x (Int) Int)(assert (x 0))"; if (Solvers.Z3 != solverToUse()) { assertThrows(IllegalArgumentException.class, () -> mgr.parse(query)); @@ -176,19 +195,32 @@ public void parseDeclareConflictInQueryTest3() { @Test public void parseDeclareConflictBeforeQueryTest() { + requireIntegers(); @SuppressWarnings("unused") IntegerFormula var = imgr.makeVariable("x"); String query = "(declare-fun x () Bool)(assert (= 0 x))"; assertThrows(IllegalArgumentException.class, () -> mgr.parse(query)); } + @Test + public void parseDeclareConflictBeforeBvQueryTest() { + requireBitvectors(); + @SuppressWarnings("unused") + BitvectorFormula var = bvmgr.makeVariable(8, "x"); + String query = "(declare-fun x () Bool)(assert (= 0 x))"; + assertThrows(IllegalArgumentException.class, () -> mgr.parse(query)); + } + @Test public void parseDeclareConflictAfterQueryTest() { String query = "(declare-fun x () Bool)(assert x)"; BooleanFormula formula = mgr.parse(query); Truth.assertThat(mgr.extractVariables(formula).values()).hasSize(1); - if (!EnumSet.of(Solvers.PRINCESS, Solvers.Z3).contains(solverToUse())) { + if (!EnumSet.of(Solvers.PRINCESS, Solvers.Z3, Solvers.BITWUZLA).contains(solverToUse())) { assertThrows(IllegalArgumentException.class, () -> imgr.makeVariable("x")); + } else if (EnumSet.of(Solvers.BITWUZLA).contains(solverToUse())) { + Truth.assertThat(mgr.extractVariables(formula).values()) + .doesNotContain(bvmgr.makeVariable(32, "x")); } else { Truth.assertThat(mgr.extractVariables(formula).values()) .doesNotContain(imgr.makeVariable("x")); @@ -201,6 +233,9 @@ public void parseDeclareOnceNotTwiceTest1() { String query2 = "(assert (not x))"; BooleanFormula formula1 = mgr.parse(query1); Truth.assertThat(mgr.extractVariables(formula1).values()).hasSize(1); + assume().that(solverToUse()).isNotEqualTo(Solvers.BITWUZLA); + // Bitwuzla just throws an error for this case + // TODO: investigate and report to the devs BooleanFormula formula2 = mgr.parse(query2); Truth.assertThat(mgr.extractVariables(formula2).values()).hasSize(1); Truth.assertThat(mgr.extractVariables(formula1)).isEqualTo(mgr.extractVariables(formula2)); @@ -214,11 +249,15 @@ public void parseTwiceTest1() { Truth.assertThat(mgr.extractVariables(formula1).values()).hasSize(1); BooleanFormula formula2 = mgr.parse(query2); Truth.assertThat(mgr.extractVariables(formula2).values()).hasSize(1); + assume().that(solverToUse()).isNotEqualTo(Solvers.BITWUZLA); + // Bitwuzla returns 2 distinct variables + // TODO: investigate and fix Truth.assertThat(formula1).isEqualTo(formula2); } @Test public void parseDeclareOnceNotTwiceTest2() { + requireIntegers(); String query1 = "(declare-fun x () Bool)(declare-fun foo (Int Int) Bool)(assert (= (foo 1 2) x))"; String query2 = "(assert (and (not x) (foo 3 4)))"; @@ -236,6 +275,9 @@ public void parseDeclareOnceNotTwiceTest3() { String query2 = "(assert y)"; BooleanFormula formula1 = mgr.parse(query1); Truth.assertThat(mgr.extractVariablesAndUFs(formula1).values()).hasSize(1); + assume().that(solverToUse()).isNotEqualTo(Solvers.BITWUZLA); + // Bitwuzla just throws an error for this case + // TODO: investigate and report to the devs if (Solvers.Z3 == solverToUse()) { // "y" is unknown for the second query. assertThrows(IllegalArgumentException.class, () -> mgr.parse(query2)); diff --git a/src/org/sosy_lab/java_smt/test/SolverFormulaIOTest.java b/src/org/sosy_lab/java_smt/test/SolverFormulaIOTest.java index 125a3a568e..4cd505f661 100644 --- a/src/org/sosy_lab/java_smt/test/SolverFormulaIOTest.java +++ b/src/org/sosy_lab/java_smt/test/SolverFormulaIOTest.java @@ -19,6 +19,7 @@ import com.google.common.collect.Iterables; import com.google.common.collect.Multiset; import com.google.common.truth.TruthJUnit; +import java.util.Arrays; import java.util.List; import java.util.function.Supplier; import org.junit.Test; @@ -108,8 +109,26 @@ public void varDumpTest() { BooleanFormula d = bmgr.and(c1, c2); String formDump = mgr.dumpFormula(d).toString(); - assertThat(formDump).contains("(declare-fun |main::a| () Bool)"); - assertThat(formDump).contains("(declare-fun b () Bool)"); + checkVariableIsDeclared(formDump, "|main::a|", "Bool"); + checkVariableIsDeclared(formDump, "b", "Bool"); + checkThatAssertIsInLastLine(formDump); + checkThatDumpIsParseable(formDump); + } + + @Test + public void varWithSpaceDumpTest() { + // Boolector will fail this anyway since bools are bitvecs for btor + TruthJUnit.assume().that(solver).isNotEqualTo(Solvers.BOOLECTOR); + + BooleanFormula a = bmgr.makeVariable("main a"); + BooleanFormula b = bmgr.makeVariable("b"); + BooleanFormula c1 = bmgr.xor(a, b); + BooleanFormula c2 = bmgr.xor(a, b); + BooleanFormula d = bmgr.and(c1, c2); + + String formDump = mgr.dumpFormula(d).toString(); + checkVariableIsDeclared(formDump, "|main a|", "Bool"); + checkVariableIsDeclared(formDump, "b", "Bool"); checkThatAssertIsInLastLine(formDump); checkThatDumpIsParseable(formDump); } @@ -138,8 +157,9 @@ public void varDumpTest2() { BooleanFormula branchComp = bmgr.or(branch1, branch2); String formDump = mgr.dumpFormula(branchComp).toString(); - assertThat(formDump).contains("(declare-fun a () Bool)"); - assertThat(formDump).contains("(declare-fun b () Bool)"); + + checkVariableIsDeclared(formDump, "a", "Bool"); + checkVariableIsDeclared(formDump, "b", "Bool"); // The serialization has to be parse-able. checkThatDumpIsParseable(formDump); @@ -149,6 +169,7 @@ public void varDumpTest2() { public void valDumpTest() { // Boolector will fail this anyway since bools are bitvecs for btor TruthJUnit.assume().that(solver).isNotEqualTo(Solvers.BOOLECTOR); + BooleanFormula tr1 = bmgr.makeBoolean(true); BooleanFormula tr2 = bmgr.makeBoolean(true); BooleanFormula fl1 = bmgr.makeBoolean(false); @@ -160,6 +181,7 @@ public void valDumpTest() { BooleanFormula valComp5 = bmgr.or(valComp3, valComp4); String formDump = mgr.dumpFormula(valComp5).toString(); + checkThatAssertIsInLastLine(formDump); checkThatDumpIsParseable(formDump); } @@ -190,7 +212,7 @@ public void bvDumpTest() { String formDump = mgr.dumpFormula(formula).toString(); // check that int variable is declared correctly + necessary assert that has to be there - assertThat(formDump).contains("(declare-fun a () (_ BitVec 8))"); + checkVariableIsDeclared(formDump, "a", "(_ BitVec 8)"); checkThatAssertIsInLastLine(formDump); checkThatDumpIsParseable(formDump); } @@ -217,6 +239,9 @@ public void funcsDumpTest() { @Test public void parseMathSatTestParseFirst1() throws SolverException, InterruptedException { requireParser(); + assume().that(solverToUse()).isNotEqualTo(Solvers.BITWUZLA); + // Bitwuzla returns 2 distinct variables + // TODO: investigate and fix compareParseWithOrgParseFirst(MATHSAT_DUMP1, this::genBoolExpr); } @@ -229,30 +254,43 @@ public void parseMathSatTestExprFirst1() throws SolverException, InterruptedExce @Test public void parseSmtinterpolTestParseFirst1() throws SolverException, InterruptedException { requireParser(); + assume().that(solverToUse()).isNotEqualTo(Solvers.BITWUZLA); + // Bitwuzla returns 2 distinct variables + // TODO: investigate and fix compareParseWithOrgParseFirst(SMTINTERPOL_DUMP1, this::genBoolExpr); } @Test public void parseSmtinterpolTestExprFirst1() throws SolverException, InterruptedException { requireParser(); + assume().that(solverToUse()).isNotEqualTo(Solvers.BITWUZLA); + // Bitwuzla returns 2 distinct variables + // TODO: investigate and fix compareParseWithOrgExprFirst(SMTINTERPOL_DUMP1, this::genBoolExpr); } @Test public void parseZ3TestParseFirst1() throws SolverException, InterruptedException { requireParser(); + assume().that(solverToUse()).isNotEqualTo(Solvers.BITWUZLA); + // Bitwuzla returns 2 distinct variables + // TODO: investigate and fix compareParseWithOrgParseFirst(Z3_DUMP1, this::genBoolExpr); } @Test public void parseZ3TestExprFirst1() throws SolverException, InterruptedException { requireParser(); + assume().that(solverToUse()).isNotEqualTo(Solvers.BITWUZLA); + // Bitwuzla returns 2 distinct variables + // TODO: investigate and fix compareParseWithOrgExprFirst(Z3_DUMP1, this::genBoolExpr); } @Test public void parseMathSatTestParseFirst2() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); compareParseWithOrgParseFirst(MATHSAT_DUMP2, this::redundancyExprGen); } @@ -265,6 +303,7 @@ public void parseMathSatTestExprFirst2() throws SolverException, InterruptedExce @Test public void parseSmtinterpolSatTestParseFirst2() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); compareParseWithOrgParseFirst(SMTINTERPOL_DUMP2, this::redundancyExprGen); } @@ -277,6 +316,7 @@ public void parseSmtinterpolSatTestExprFirst2() throws SolverException, Interrup @Test public void parseZ3SatTestParseFirst2() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); compareParseWithOrgParseFirst(Z3_DUMP2, this::redundancyExprGen); } @@ -289,14 +329,10 @@ public void parseZ3SatTestExprFirst2() throws SolverException, InterruptedExcept @Test public void parseMathSatTestExprFirst3() throws SolverException, InterruptedException { requireParser(); + requireIntegers(); compareParseWithOrgExprFirst(MATHSAT_DUMP3, this::functionExprGen); } - public void parseMathSatTestParseFirst3() throws SolverException, InterruptedException { - requireParser(); - compareParseWithOrgParseFirst(MATHSAT_DUMP3, this::functionExprGen); - } - @Test public void redundancyTest() { assume() @@ -368,6 +404,10 @@ private void compareParseWithOrgExprFirst(String textToParse, Supplier quantifiedVars = ImmutableList.of(imgr.makeVariable("x")); BooleanFormula body = bmgr.makeTrue(); BooleanFormula f = qmgr.exists(quantifiedVars, body); @@ -1043,6 +1050,7 @@ public void testTransformationInsideQuantifiersWithTrue() public void testTransformationInsideQuantifiersWithFalse() throws SolverException, InterruptedException { requireQuantifiers(); + requireIntegers(); List quantifiedVars = ImmutableList.of(imgr.makeVariable("x")); BooleanFormula body = bmgr.makeFalse(); BooleanFormula f = qmgr.exists(quantifiedVars, body); @@ -1055,6 +1063,7 @@ public void testTransformationInsideQuantifiersWithFalse() public void testTransformationInsideQuantifiersWithVariable() throws SolverException, InterruptedException { requireQuantifiers(); + requireIntegers(); List quantifiedVars = ImmutableList.of(imgr.makeVariable("x")); BooleanFormula body = bmgr.makeVariable("b"); BooleanFormula f = qmgr.exists(quantifiedVars, body); @@ -1065,6 +1074,7 @@ public void testTransformationInsideQuantifiersWithVariable() @Test public void extractionTest1() { + requireIntegers(); IntegerFormula v = imgr.makeVariable("v"); BooleanFormula q = fmgr.declareAndCallUF("q", FormulaType.BooleanType, v); Map mapping = mgr.extractVariablesAndUFs(q); @@ -1075,6 +1085,7 @@ public void extractionTest1() { @Test public void extractionTest2() { + requireIntegers(); // the same as above, but with nullary UF. IntegerFormula v = fmgr.declareAndCallUF("v", FormulaType.IntegerType); BooleanFormula q = fmgr.declareAndCallUF("q", FormulaType.BooleanType, v); diff --git a/src/org/sosy_lab/java_smt/test/TimeoutTest.java b/src/org/sosy_lab/java_smt/test/TimeoutTest.java index 80af046e9a..e75926a2c4 100644 --- a/src/org/sosy_lab/java_smt/test/TimeoutTest.java +++ b/src/org/sosy_lab/java_smt/test/TimeoutTest.java @@ -16,13 +16,16 @@ import java.util.Random; import java.util.function.Supplier; import org.junit.Test; +import org.junit.function.ThrowingRunnable; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.junit.runners.Parameterized.Parameter; import org.junit.runners.Parameterized.Parameters; +import org.sosy_lab.common.configuration.InvalidConfigurationException; import org.sosy_lab.java_smt.SolverContextFactory.Solvers; import org.sosy_lab.java_smt.api.BasicProverEnvironment; import org.sosy_lab.java_smt.api.BooleanFormula; +import org.sosy_lab.java_smt.api.SolverException; import org.sosy_lab.java_smt.api.Tactic; import org.sosy_lab.java_smt.solvers.opensmt.Logics; @@ -93,9 +96,29 @@ public void testProverTimeoutBv() throws InterruptedException { .withMessage(solverToUse() + " does not support interruption") .that(solverToUse()) .isNoneOf(Solvers.PRINCESS, Solvers.CVC5); + TruthJUnit.assume() + .withMessage(solverToUse() + " does not support sort/term creation in different threads.") + .that(solverToUse()) + .isNotEqualTo(Solvers.BITWUZLA); testBasicProverTimeoutBv(() -> context.newProverEnvironment()); } + @Test(timeout = TIMOUT_MILLISECONDS) + public void testProverTimeoutBvFullEnvironmentInRunnable() { + requireBitvectors(); + TruthJUnit.assume() + .withMessage(solverToUse() + " does not support interruption") + .that(solverToUse()) + .isNoneOf(Solvers.PRINCESS, Solvers.CVC5); + TruthJUnit.assume() + .withMessage( + "This test creates the formulas first, hence it fails " + + "sometimes for small timeout times.") + .that(delay) + .isAtLeast(50); + testProverTimeoutWithFullEnvironmentInThread(); + } + @Test(timeout = TIMOUT_MILLISECONDS) public void testInterpolationProverTimeout() throws InterruptedException { requireInterpolation(); @@ -147,4 +170,40 @@ private void testBasicProverTimeout( assertThrows(InterruptedException.class, pe::isUnsat); } } + + @SuppressWarnings("CheckReturnValue") + private void testProverTimeoutWithFullEnvironmentInThread() { + + Thread t = + new Thread( + () -> { + try { + Thread.sleep(delay); + shutdownManager.requestShutdown("Shutdown Request"); + } catch (InterruptedException pE) { + throw new UnsupportedOperationException("Unexpected interrupt"); + } + }); + + ThrowingRunnable runnable = + new ThrowingRunnable() { + @Override + public void run() + throws InterruptedException, SolverException, InvalidConfigurationException { + initSolver(); + // SolverContext newEnv = SolverContextFactory.createSolverContext(); + mgr = context.getFormulaManager(); + bmgr = mgr.getBooleanFormulaManager(); + bvmgr = mgr.getBitvectorFormulaManager(); + HardBitvectorFormulaGenerator gen = new HardBitvectorFormulaGenerator(bvmgr, bmgr); + try (BasicProverEnvironment pe = context.newProverEnvironment()) { + pe.push(gen.generate(100)); + pe.isUnsat(); + } + } + }; + + t.start(); + assertThrows(InterruptedException.class, runnable); + } } diff --git a/src/org/sosy_lab/java_smt/test/TranslateFormulaTest.java b/src/org/sosy_lab/java_smt/test/TranslateFormulaTest.java index 28d3851267..25006d6cb6 100644 --- a/src/org/sosy_lab/java_smt/test/TranslateFormulaTest.java +++ b/src/org/sosy_lab/java_smt/test/TranslateFormulaTest.java @@ -107,7 +107,7 @@ private void requireIntegers() { assume() .withMessage("Solver %s does not support integer theory", translateFrom) .that(translateFrom) - .isNotEqualTo(Solvers.BOOLECTOR); + .isNoneOf(Solvers.BOOLECTOR, Solvers.BITWUZLA); } @Test @@ -134,6 +134,7 @@ public void testTranslating() throws SolverException, InterruptedException { @Test public void testTranslatingForIContextIdentity() throws SolverException, InterruptedException { + requireIntegers(); assume().that(translateTo).isEqualTo(translateFrom); FormulaManager manager = managerFrom; @@ -146,6 +147,7 @@ public void testTranslatingForIContextIdentity() throws SolverException, Interru @Test public void testTranslatingForContextSibling() throws SolverException, InterruptedException { + requireIntegers(); assume().that(translateTo).isEqualTo(translateFrom); assume() diff --git a/src/org/sosy_lab/java_smt/test/UFManagerTest.java b/src/org/sosy_lab/java_smt/test/UFManagerTest.java index a14e90d21f..9a8fa079e5 100644 --- a/src/org/sosy_lab/java_smt/test/UFManagerTest.java +++ b/src/org/sosy_lab/java_smt/test/UFManagerTest.java @@ -301,6 +301,7 @@ public void testDeclareAndCallUFWithTypedArgs() { requireBooleanArgument(); createAndCallUF("fooBool1", FormulaType.BooleanType, bmgr.makeTrue()); createAndCallUF("fooBool2", FormulaType.BooleanType, bmgr.makeTrue(), bmgr.makeTrue()); + requireIntegers(); createAndCallUF( "fooBool3", FormulaType.IntegerType, bmgr.makeTrue(), bmgr.makeTrue(), bmgr.makeTrue()); @@ -337,6 +338,7 @@ public void testDeclareAndCallUFWithRationalArgs() { @Test public void testDeclareAndCallUFWithBVArgs() { requireBitvectors(); + requireIntegers(); createAndCallUF("fooBV1", FormulaType.getBitvectorTypeWithSize(5), bvmgr.makeBitvector(3, 3L)); requireBooleanArgument(); createAndCallUF( diff --git a/src/org/sosy_lab/java_smt/test/UserPropagatorTest.java b/src/org/sosy_lab/java_smt/test/UserPropagatorTest.java index 3164417ea8..6522af29fb 100644 --- a/src/org/sosy_lab/java_smt/test/UserPropagatorTest.java +++ b/src/org/sosy_lab/java_smt/test/UserPropagatorTest.java @@ -48,7 +48,9 @@ public void testWithBlockedLiterals() throws SolverException, InterruptedExcepti } } - /** This user propagator will raise a conflict whenever a registered expression is set to true. */ + /** + * This user propagator will raise a conflict whenever a registered expression is set to true. + */ private static class TestUserPropagator extends AbstractUserPropagator { private final List disabledExpressions = new ArrayList<>(); @@ -56,7 +58,7 @@ private static class TestUserPropagator extends AbstractUserPropagator { @Override public void onKnownValue(BooleanFormula expr, boolean value) { if (value && disabledExpressions.contains(expr)) { - getBackend().propagateConflict(new BooleanFormula[] {expr}); + getBackend().propagateConflict(new BooleanFormula[]{expr}); } }