repo
stringlengths 1
191
⌀ | file
stringlengths 23
351
| code
stringlengths 0
5.32M
| file_length
int64 0
5.32M
| avg_line_length
float64 0
2.9k
| max_line_length
int64 0
288k
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5BooleanFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import com.google.common.collect.Iterables;
import io.github.cvc5.CVC5ApiException;
import io.github.cvc5.Kind;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.Set;
import org.sosy_lab.java_smt.basicimpl.AbstractBooleanFormulaManager;
public class CVC5BooleanFormulaManager
extends AbstractBooleanFormulaManager<Term, Sort, Solver, Term> {
private final Solver solver;
private final Term pTrue;
private final Term pFalse;
protected CVC5BooleanFormulaManager(CVC5FormulaCreator pCreator) {
super(pCreator);
solver = pCreator.getEnv();
pTrue = solver.mkBoolean(true);
pFalse = solver.mkBoolean(false);
}
@Override
protected Term makeVariableImpl(String pVar) {
return formulaCreator.makeVariable(getFormulaCreator().getBoolType(), pVar);
}
@Override
protected Term makeBooleanImpl(boolean pValue) {
return pValue ? pTrue : pFalse;
}
@Override
protected Term not(Term pParam1) {
try {
if (isTrue(pParam1)) {
return pFalse;
} else if (isFalse(pParam1)) {
return pTrue;
} else if (pParam1.getKind() == Kind.NOT) {
return pParam1.getChild(0);
}
} catch (CVC5ApiException e) {
throw new IllegalArgumentException("Failure when negating the term '" + pParam1 + "'.", e);
}
return solver.mkTerm(Kind.NOT, pParam1);
}
@Override
protected Term and(Term pParam1, Term 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 solver.mkTerm(Kind.AND, pParam1, pParam2);
}
@Override
protected Term andImpl(Collection<Term> pParams) {
// CVC5 does not do any simplifications,
// so we filter "true", short-circuit on "false", and filter out (simple) redundancies.
final Set<Term> operands = new LinkedHashSet<>();
for (final Term operand : pParams) {
if (isFalse(operand)) {
return pFalse;
}
if (!isTrue(operand)) {
operands.add(operand);
}
}
switch (operands.size()) {
case 0:
return pTrue;
case 1:
return Iterables.getOnlyElement(operands);
default:
return solver.mkTerm(Kind.AND, operands.toArray(new Term[0]));
}
}
@Override
protected Term or(Term pParam1, Term 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 solver.mkTerm(Kind.OR, pParam1, pParam2);
}
@Override
protected Term orImpl(Collection<Term> pParams) {
// CVC5 does not do any simplifications,
// so we filter "true", short-circuit on "false", and filter out (simple) redundancies.
final Set<Term> operands = new LinkedHashSet<>();
for (final Term operand : pParams) {
if (isTrue(operand)) {
return pTrue;
}
if (!isFalse(operand)) {
operands.add(operand);
}
}
switch (operands.size()) {
case 0:
return pFalse;
case 1:
return Iterables.getOnlyElement(operands);
default:
return solver.mkTerm(Kind.OR, operands.toArray(new Term[0]));
}
}
@Override
protected Term xor(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.XOR, pParam1, pParam2);
}
@Override
protected Term equivalence(Term pBits1, Term pBits2) {
return solver.mkTerm(Kind.EQUAL, pBits1, pBits2);
}
@Override
protected Term implication(Term bits1, Term bits2) {
return solver.mkTerm(Kind.IMPLIES, bits1, bits2);
}
@Override
protected boolean isTrue(Term pBits) {
return pBits.isBooleanValue() && pBits.getBooleanValue();
}
@Override
protected boolean isFalse(Term pBits) {
return pBits.isBooleanValue() && !pBits.getBooleanValue();
}
@Override
protected Term ifThenElse(Term pCond, Term pF1, Term 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 solver.mkTerm(Kind.ITE, pCond, pF1, pF2);
}
}
| 4,917 | 26.171271 | 97 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5EnumerationFormulaManager.java | // 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 <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import com.google.common.collect.ImmutableMap;
import io.github.cvc5.DatatypeConstructorDecl;
import io.github.cvc5.Kind;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import org.sosy_lab.java_smt.api.FormulaType.EnumerationFormulaType;
import org.sosy_lab.java_smt.basicimpl.AbstractEnumerationFormulaManager;
import org.sosy_lab.java_smt.basicimpl.FormulaCreator;
public class CVC5EnumerationFormulaManager
extends AbstractEnumerationFormulaManager<Term, Sort, Solver, Term> {
private final Solver solver;
protected CVC5EnumerationFormulaManager(FormulaCreator<Term, Sort, Solver, Term> pCreator) {
super(pCreator);
solver = pCreator.getEnv();
}
@Override
protected EnumType declareEnumeration0(EnumerationFormulaType pType) {
DatatypeConstructorDecl[] constructors =
pType.getElements().stream()
.map(solver::mkDatatypeConstructorDecl)
.toArray(DatatypeConstructorDecl[]::new);
Sort enumType = solver.declareDatatype(pType.getName(), constructors);
// we store the constants for later access
ImmutableMap.Builder<String, Term> constantsMapping = ImmutableMap.builder();
for (String element : pType.getElements()) {
Term decl = enumType.getDatatype().getConstructor(element).getTerm();
constantsMapping.put(element, solver.mkTerm(Kind.APPLY_CONSTRUCTOR, decl));
}
return new EnumType(pType, enumType, constantsMapping.buildOrThrow());
}
@Override
protected Term equivalenceImpl(Term pF1, Term pF2) {
return solver.mkTerm(Kind.EQUAL, pF1, pF2);
}
}
| 1,887 | 34.622642 | 94 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5Evaluator.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import com.google.common.base.Preconditions;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import org.sosy_lab.java_smt.basicimpl.AbstractEvaluator;
public class CVC5Evaluator extends AbstractEvaluator<Term, Sort, Solver> {
private final Solver solver;
CVC5Evaluator(CVC5AbstractProver<?> pProver, CVC5FormulaCreator pCreator) {
super(pProver, pCreator);
solver = pProver.solver;
}
@Override
public Term evalImpl(Term f) {
Preconditions.checkState(!isClosed());
return solver.getValue(f);
}
}
| 850 | 25.59375 | 77 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5FloatingPointFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import com.google.common.collect.ImmutableList;
import io.github.cvc5.CVC5ApiException;
import io.github.cvc5.Kind;
import io.github.cvc5.Op;
import io.github.cvc5.RoundingMode;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import java.math.BigDecimal;
import org.sosy_lab.common.rationals.Rational;
import org.sosy_lab.java_smt.api.FloatingPointRoundingMode;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.FormulaType.BitvectorType;
import org.sosy_lab.java_smt.api.FormulaType.FloatingPointType;
import org.sosy_lab.java_smt.basicimpl.AbstractFloatingPointFormulaManager;
public class CVC5FloatingPointFormulaManager
extends AbstractFloatingPointFormulaManager<Term, Sort, Solver, Term> {
private final Solver solver;
private final Term roundingMode;
protected CVC5FloatingPointFormulaManager(
CVC5FormulaCreator pCreator, FloatingPointRoundingMode pFloatingPointRoundingMode) {
super(pCreator);
solver = pCreator.getEnv();
roundingMode = getRoundingModeImpl(pFloatingPointRoundingMode);
}
@Override
protected Term getDefaultRoundingMode() {
return roundingMode;
}
@Override
protected Term getRoundingModeImpl(FloatingPointRoundingMode pFloatingPointRoundingMode) {
switch (pFloatingPointRoundingMode) {
case NEAREST_TIES_TO_EVEN:
return solver.mkRoundingMode(RoundingMode.ROUND_NEAREST_TIES_TO_EVEN);
case NEAREST_TIES_AWAY:
return solver.mkRoundingMode(RoundingMode.ROUND_NEAREST_TIES_TO_AWAY);
case TOWARD_POSITIVE:
return solver.mkRoundingMode(RoundingMode.ROUND_TOWARD_POSITIVE);
case TOWARD_NEGATIVE:
return solver.mkRoundingMode(RoundingMode.ROUND_TOWARD_NEGATIVE);
case TOWARD_ZERO:
return solver.mkRoundingMode(RoundingMode.ROUND_TOWARD_ZERO);
default:
throw new AssertionError(
"Unexpected rounding mode encountered: " + pFloatingPointRoundingMode);
}
}
@Override
protected Term makeNumberImpl(double pN, FloatingPointType pType, Term pRoundingMode) {
return makeNumberImpl(Double.toString(pN), pType, pRoundingMode);
}
@Override
protected Term makeNumberAndRound(String pN, FloatingPointType pType, Term pRoundingMode) {
try {
if (isNegativeZero(Double.valueOf(pN))) {
return solver.mkFloatingPointNegZero(pType.getExponentSize(), pType.getMantissaSize() + 1);
}
} catch (CVC5ApiException | NumberFormatException e) {
// ignore and fallback to floating point from rational numbers
}
try {
Rational rationalValue = toRational(pN);
Op realToFp =
solver.mkOp(
Kind.FLOATINGPOINT_TO_FP_FROM_REAL,
pType.getExponentSize(),
pType.getMantissaSize() + 1);
return solver.mkTerm(realToFp, pRoundingMode, solver.mkReal(rationalValue.toString()));
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"You tried creating a invalid floating point with exponent size "
+ pType.getExponentSize()
+ ", mantissa size "
+ pType.getMantissaSize()
+ " and value "
+ pN
+ ".",
e);
}
}
/**
* Try to convert a String numeral into a Rational.
*
* <p>If we do not check all invalid formatted numbers in our own code, CVC5 will fail hard and
* immediately terminate the whole program.
*/
private Rational toRational(String pN) throws NumberFormatException {
try {
// first try something like -123.567
return Rational.ofBigDecimal(new BigDecimal(pN));
} catch (NumberFormatException e1) {
try {
// then try something like -123/456
return org.sosy_lab.common.rationals.Rational.ofString(pN);
} catch (NumberFormatException e2) {
// we cannot handle the number
throw new NumberFormatException("invalid numeral: " + pN);
}
}
}
@Override
protected Term makeVariableImpl(String varName, FloatingPointType pType) {
return formulaCreator.makeVariable(formulaCreator.getFloatingPointType(pType), varName);
}
@Override
protected Term makePlusInfinityImpl(FloatingPointType pType) {
try {
return solver.mkFloatingPointPosInf(pType.getExponentSize(), pType.getMantissaSize() + 1);
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"You tried creating a invalid positive floating point +infinity with exponent size "
+ pType.getExponentSize()
+ " and mantissa size "
+ pType.getMantissaSize()
+ ".",
e);
}
}
@Override
protected Term makeMinusInfinityImpl(FloatingPointType pType) {
try {
return solver.mkFloatingPointNegInf(pType.getExponentSize(), pType.getMantissaSize() + 1);
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"You tried creating a invalid negative floating point -infinity with exponent size "
+ pType.getExponentSize()
+ " and mantissa size "
+ pType.getMantissaSize()
+ ".",
e);
}
}
@Override
protected Term makeNaNImpl(FloatingPointType pType) {
try {
return solver.mkFloatingPointNaN(pType.getExponentSize(), pType.getMantissaSize() + 1);
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"You tried creating a invalid NaN with exponent size "
+ pType.getExponentSize()
+ " and mantissa size "
+ pType.getMantissaSize()
+ ".",
e);
}
}
// FP -> other type
@Override
protected Term castToImpl(
Term pNumber, boolean pSigned, FormulaType<?> pTargetType, Term pRoundingMode) {
try {
if (pTargetType.isFloatingPointType()) {
Op fpToFp =
solver.mkOp(
Kind.FLOATINGPOINT_TO_FP_FROM_FP,
((FloatingPointType) pTargetType).getExponentSize(),
((FloatingPointType) pTargetType).getMantissaSize() + 1);
return solver.mkTerm(fpToFp, pRoundingMode, pNumber);
} else if (pTargetType.isBitvectorType()) {
BitvectorType targetType = (BitvectorType) pTargetType;
Kind kind = pSigned ? Kind.FLOATINGPOINT_TO_SBV : Kind.FLOATINGPOINT_TO_UBV;
Op operation = solver.mkOp(kind, targetType.getSize());
return solver.mkTerm(operation, pRoundingMode, pNumber);
} else if (pTargetType.isRationalType()) {
return solver.mkTerm(Kind.FLOATINGPOINT_TO_REAL, pNumber);
} else {
return genericCast(pNumber, pTargetType);
}
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"You tried creating a invalid cast from "
+ pNumber
+ " into a "
+ pTargetType
+ ". Check that the target type can hold the source type. (Note: for target FP types"
+ " 1 bit is missing in this debug message)",
e);
}
}
// other type -> FP
@Override
protected Term castFromImpl(
Term pNumber, boolean pSigned, FloatingPointType pTargetType, Term pRoundingMode) {
FormulaType<?> formulaType = getFormulaCreator().getFormulaType(pNumber);
try {
if (formulaType.isFloatingPointType()) {
return castToImpl(pNumber, pSigned, pTargetType, pRoundingMode);
} else if (formulaType.isRationalType()) {
Op realToFp =
solver.mkOp(
Kind.FLOATINGPOINT_TO_FP_FROM_REAL,
pTargetType.getExponentSize(),
pTargetType.getMantissaSize() + 1);
return solver.mkTerm(realToFp, pRoundingMode, pNumber);
} else if (formulaType.isBitvectorType()) {
if (pSigned) {
Op realToSBv =
solver.mkOp(
Kind.FLOATINGPOINT_TO_FP_FROM_SBV,
pTargetType.getExponentSize(),
pTargetType.getMantissaSize() + 1);
return solver.mkTerm(realToSBv, pRoundingMode, pNumber);
} else {
Op realToUBv =
solver.mkOp(
Kind.FLOATINGPOINT_TO_FP_FROM_UBV,
pTargetType.getExponentSize(),
pTargetType.getMantissaSize() + 1);
return solver.mkTerm(realToUBv, pRoundingMode, pNumber);
}
} else {
// Generic cast was removed in the 1.0.0 version
return genericCast(pNumber, pTargetType);
}
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"You tried creating a invalid cast from "
+ pNumber
+ " into a FloatingPoint with exponent size "
+ pTargetType.getExponentSize()
+ " and mantissa size "
+ pTargetType.getMantissaSize()
+ ".",
e);
}
}
private Term genericCast(Term pNumber, FormulaType<?> pTargetType) {
Sort type = pNumber.getSort();
FormulaType<?> argType = getFormulaCreator().getFormulaType(pNumber);
Term castFuncDecl =
getFormulaCreator()
.declareUFImpl(
"__cast_" + argType + "_to_" + pTargetType,
toSolverType(pTargetType),
ImmutableList.of(type));
return solver.mkTerm(Kind.APPLY_UF, castFuncDecl, pNumber);
}
@Override
protected Term negate(Term pParam1) {
return solver.mkTerm(Kind.FLOATINGPOINT_NEG, pParam1);
}
@Override
protected Term abs(Term pParam1) {
return solver.mkTerm(Kind.FLOATINGPOINT_ABS, pParam1);
}
@Override
protected Term max(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.FLOATINGPOINT_MAX, pParam1, pParam2);
}
@Override
protected Term min(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.FLOATINGPOINT_MIN, pParam1, pParam2);
}
@Override
protected Term sqrt(Term pParam1, Term pRoundingMode) {
return solver.mkTerm(Kind.FLOATINGPOINT_SQRT, pRoundingMode, pParam1);
}
@Override
protected Term add(Term pParam1, Term pParam2, Term pRoundingMode) {
return solver.mkTerm(Kind.FLOATINGPOINT_ADD, pRoundingMode, pParam1, pParam2);
}
@Override
protected Term subtract(Term pParam1, Term pParam2, Term pRoundingMode) {
return solver.mkTerm(Kind.FLOATINGPOINT_SUB, pRoundingMode, pParam1, pParam2);
}
@Override
protected Term divide(Term pParam1, Term pParam2, Term pRoundingMode) {
return solver.mkTerm(Kind.FLOATINGPOINT_DIV, pRoundingMode, pParam1, pParam2);
}
@Override
protected Term multiply(Term pParam1, Term pParam2, Term pRoundingMode) {
return solver.mkTerm(Kind.FLOATINGPOINT_MULT, pRoundingMode, pParam1, pParam2);
}
@Override
protected Term assignment(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.EQUAL, pParam1, pParam2);
}
@Override
protected Term equalWithFPSemantics(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.FLOATINGPOINT_EQ, pParam1, pParam2);
}
@Override
protected Term greaterThan(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.FLOATINGPOINT_GT, pParam1, pParam2);
}
@Override
protected Term greaterOrEquals(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.FLOATINGPOINT_GEQ, pParam1, pParam2);
}
@Override
protected Term lessThan(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.FLOATINGPOINT_LT, pParam1, pParam2);
}
@Override
protected Term lessOrEquals(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.FLOATINGPOINT_LEQ, pParam1, pParam2);
}
@Override
protected Term isNaN(Term pParam1) {
return solver.mkTerm(Kind.FLOATINGPOINT_IS_NAN, pParam1);
}
@Override
protected Term isInfinity(Term pParam1) {
return solver.mkTerm(Kind.FLOATINGPOINT_IS_INF, pParam1);
}
@Override
protected Term isZero(Term pParam1) {
return solver.mkTerm(Kind.FLOATINGPOINT_IS_ZERO, pParam1);
}
@Override
protected Term isSubnormal(Term pParam1) {
return solver.mkTerm(Kind.FLOATINGPOINT_IS_SUBNORMAL, pParam1);
}
@Override
protected Term isNormal(Term pParam) {
return solver.mkTerm(Kind.FLOATINGPOINT_IS_NORMAL, pParam);
}
@Override
protected Term isNegative(Term pParam) {
return solver.mkTerm(Kind.FLOATINGPOINT_IS_NEG, pParam);
}
@Override
protected Term fromIeeeBitvectorImpl(Term pNumber, FloatingPointType pTargetType) {
return solver.mkTerm(Kind.FLOATINGPOINT_TO_FP_FROM_IEEE_BV, pNumber);
}
@Override
protected Term toIeeeBitvectorImpl(Term pNumber) {
// TODO possible work-around: use a tmp-variable "TMP" and add an
// additional constraint "pNumer == fromIeeeBitvectorImpl(TMP)" for it in all use-cases.
// --> This has to be done on user-side, not in JavaSMT.
throw new UnsupportedOperationException("FP to IEEE-BV is not supported");
}
@Override
protected Term round(Term pFormula, FloatingPointRoundingMode pRoundingMode) {
return solver.mkTerm(Kind.FLOATINGPOINT_RTI, getRoundingModeImpl(pRoundingMode), pFormula);
}
}
| 13,418 | 32.71608 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5Formula.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import com.google.errorprone.annotations.Immutable;
import io.github.cvc5.Term;
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.EnumerationFormula;
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.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.NumeralFormula.RationalFormula;
import org.sosy_lab.java_smt.api.RegexFormula;
import org.sosy_lab.java_smt.api.StringFormula;
@Immutable
public class CVC5Formula implements Formula {
@SuppressWarnings("Immutable")
private final Term cvc5term;
CVC5Formula(Term term) {
cvc5term = term;
}
@Override
public final String toString() {
return cvc5term.toString();
}
@Override
public final boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof CVC5Formula)) {
return false;
}
return cvc5term.equals(((CVC5Formula) o).cvc5term);
}
@Override
public final int hashCode() {
return Long.hashCode(cvc5term.getId());
}
final Term getTerm() {
return cvc5term;
}
@Immutable
@SuppressWarnings("ClassTypeParameterName")
static final class CVC5ArrayFormula<TI extends Formula, TE extends Formula> extends CVC5Formula
implements ArrayFormula<TI, TE> {
private final FormulaType<TI> indexType;
private final FormulaType<TE> elementType;
CVC5ArrayFormula(Term pTerm, FormulaType<TI> pIndexType, FormulaType<TE> pElementType) {
super(pTerm);
indexType = pIndexType;
elementType = pElementType;
}
public FormulaType<TI> getIndexType() {
return indexType;
}
public FormulaType<TE> getElementType() {
return elementType;
}
}
@Immutable
static final class CVC5BitvectorFormula extends CVC5Formula implements BitvectorFormula {
CVC5BitvectorFormula(Term pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC5FloatingPointFormula extends CVC5Formula implements FloatingPointFormula {
CVC5FloatingPointFormula(Term pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC5FloatingPointRoundingModeFormula extends CVC5Formula
implements FloatingPointRoundingModeFormula {
CVC5FloatingPointRoundingModeFormula(Term pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC5IntegerFormula extends CVC5Formula implements IntegerFormula {
CVC5IntegerFormula(Term pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC5RationalFormula extends CVC5Formula implements RationalFormula {
CVC5RationalFormula(Term pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC5BooleanFormula extends CVC5Formula implements BooleanFormula {
CVC5BooleanFormula(Term pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC5StringFormula extends CVC5Formula implements StringFormula {
CVC5StringFormula(Term pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC5RegexFormula extends CVC5Formula implements RegexFormula {
CVC5RegexFormula(Term pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC5EnumerationFormula extends CVC5Formula implements EnumerationFormula {
CVC5EnumerationFormula(Term pTerm) {
super(pTerm);
}
}
}
| 3,875 | 25.189189 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5FormulaCreator.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import io.github.cvc5.CVC5ApiException;
import io.github.cvc5.Datatype;
import io.github.cvc5.DatatypeConstructor;
import io.github.cvc5.Kind;
import io.github.cvc5.Op;
import io.github.cvc5.Pair;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import io.github.cvc5.Triplet;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.sosy_lab.common.rationals.Rational;
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.EnumerationFormula;
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.RegexFormula;
import org.sosy_lab.java_smt.api.StringFormula;
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.cvc5.CVC5Formula.CVC5ArrayFormula;
import org.sosy_lab.java_smt.solvers.cvc5.CVC5Formula.CVC5BitvectorFormula;
import org.sosy_lab.java_smt.solvers.cvc5.CVC5Formula.CVC5BooleanFormula;
import org.sosy_lab.java_smt.solvers.cvc5.CVC5Formula.CVC5EnumerationFormula;
import org.sosy_lab.java_smt.solvers.cvc5.CVC5Formula.CVC5FloatingPointFormula;
import org.sosy_lab.java_smt.solvers.cvc5.CVC5Formula.CVC5FloatingPointRoundingModeFormula;
import org.sosy_lab.java_smt.solvers.cvc5.CVC5Formula.CVC5IntegerFormula;
import org.sosy_lab.java_smt.solvers.cvc5.CVC5Formula.CVC5RationalFormula;
import org.sosy_lab.java_smt.solvers.cvc5.CVC5Formula.CVC5RegexFormula;
import org.sosy_lab.java_smt.solvers.cvc5.CVC5Formula.CVC5StringFormula;
public class CVC5FormulaCreator extends FormulaCreator<Term, Sort, Solver, Term> {
/** CVC5 does not allow using some key-functions from SMTLIB2 as identifiers. */
private static final ImmutableSet<String> UNSUPPORTED_IDENTIFIERS = ImmutableSet.of("let");
// private static final Pattern FLOATING_POINT_PATTERN = Pattern.compile("^\\(fp #b(?<sign>\\d)
// #b(?<exp>\\d+) #b(?<mant>\\d+)$");
private final Map<String, Term> variablesCache = new HashMap<>();
private final Map<String, Term> functionsCache = new HashMap<>();
private final Solver solver;
protected CVC5FormulaCreator(Solver pSolver) {
super(
pSolver,
pSolver.getBooleanSort(),
pSolver.getIntegerSort(),
pSolver.getRealSort(),
pSolver.getStringSort(),
pSolver.getRegExpSort());
solver = pSolver;
}
@Override
public Term makeVariable(Sort sort, String name) {
checkSymbol(name);
Term exp = variablesCache.computeIfAbsent(name, n -> solver.mkConst(sort, name));
Preconditions.checkArgument(
sort.equals(exp.getSort()),
"symbol name %s with sort %s already in use for different sort %s",
name,
sort,
exp.getSort());
return exp;
}
/**
* Makes a bound copy of a variable for use in quantifier. Note that all occurrences of the free
* var have to be substituted by the bound once it exists.
*
* @param var Variable you want a bound copy of.
* @return Bound Variable
*/
public Term makeBoundCopy(Term var) {
Sort sort = var.getSort();
String name = getName(var);
Term boundCopy = solver.mkVar(sort, name);
return boundCopy;
}
@Override
public Sort getBitvectorType(int pBitwidth) {
try {
return solver.mkBitVectorSort(pBitwidth);
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"Cannot create bitvector sort with size " + pBitwidth + ".", e);
}
}
@Override
public Sort getFloatingPointType(FloatingPointType pType) {
try {
// plus sign bit
return solver.mkFloatingPointSort(pType.getExponentSize(), pType.getMantissaSize() + 1);
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"Cannot create floatingpoint sort with exponent size "
+ pType.getExponentSize()
+ " and mantissa "
+ pType.getMantissaSize()
+ " (plus sign bit).",
e);
}
}
@Override
public Sort getArrayType(Sort pIndexType, Sort pElementType) {
return solver.mkArraySort(pIndexType, pElementType);
}
@Override
public Term extractInfo(Formula pT) {
return CVC5FormulaManager.getCVC5Term(pT);
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TD extends Formula, TR extends Formula> FormulaType<TR> getArrayFormulaElementType(
ArrayFormula<TD, TR> pArray) {
return ((CVC5ArrayFormula<TD, TR>) pArray).getElementType();
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TD extends Formula, TR extends Formula> FormulaType<TD> getArrayFormulaIndexType(
ArrayFormula<TD, TR> pArray) {
return ((CVC5ArrayFormula<TD, TR>) pArray).getIndexType();
}
@SuppressWarnings("unchecked")
@Override
public <T extends Formula> FormulaType<T> getFormulaType(T pFormula) {
Sort cvc5sort = extractInfo(pFormula).getSort();
if (pFormula instanceof BitvectorFormula) {
checkArgument(
cvc5sort.isBitVector(), "BitvectorFormula with actual type %s: %s", cvc5sort, pFormula);
return (FormulaType<T>) getFormulaTypeFromTermType(cvc5sort);
} else if (pFormula instanceof FloatingPointFormula) {
checkArgument(
cvc5sort.isFloatingPoint(),
"FloatingPointFormula with actual type %s: %s",
cvc5sort,
pFormula);
return (FormulaType<T>) getFormulaTypeFromTermType(cvc5sort);
} else if (pFormula instanceof ArrayFormula<?, ?>) {
checkArgument(cvc5sort.isArray(), "ArrayFormula with actual type %s: %s", cvc5sort, pFormula);
return (FormulaType<T>) getFormulaTypeFromTermType(cvc5sort);
} else if (pFormula instanceof EnumerationFormula) {
checkArgument(
cvc5sort.isDatatype(), "EnumerationFormula with actual type %s: %s", cvc5sort, pFormula);
return (FormulaType<T>) getFormulaTypeFromTermType(cvc5sort);
} else {
return super.getFormulaType(pFormula);
}
}
@Override
public FormulaType<?> getFormulaType(Term pFormula) {
return getFormulaTypeFromTermType(pFormula.getSort());
}
private FormulaType<?> getFormulaTypeFromTermType(Sort sort) {
if (sort.isBoolean()) {
return FormulaType.BooleanType;
} else if (sort.isInteger()) {
return FormulaType.IntegerType;
} else if (sort.isBitVector()) {
return FormulaType.getBitvectorTypeWithSize(sort.getBitVectorSize());
} else if (sort.isFloatingPoint()) {
// CVC5 wants the sign bit as part of the mantissa. We add that manually in creation.
return FormulaType.getFloatingPointType(
sort.getFloatingPointExponentSize(), sort.getFloatingPointSignificandSize() - 1);
} else if (sort.isRoundingMode()) {
return FormulaType.FloatingPointRoundingModeType;
} else if (sort.isReal()) {
// The theory REAL in CVC5 is the theory of (infinite precision!) real numbers.
// As such, the theory RATIONAL is contained in REAL.
return FormulaType.RationalType;
} else if (sort.isArray()) {
FormulaType<?> indexType = getFormulaTypeFromTermType(sort.getArrayIndexSort());
FormulaType<?> elementType = getFormulaTypeFromTermType(sort.getArrayElementSort());
return FormulaType.getArrayType(indexType, elementType);
} else if (sort.isString()) {
return FormulaType.StringType;
} else if (sort.isRegExp()) {
return FormulaType.RegexType;
} else if (sort.isFunction()) {
return getFormulaTypeFromTermType(sort.getFunctionCodomainSort());
} else if (sort.isDatatype()) {
Datatype enumType = sort.getDatatype();
return FormulaType.getEnumerationType(
enumType.getName(),
FluentIterable.from(enumType).transform(DatatypeConstructor::getName).toSet());
} else {
try {
throw new AssertionError(
String.format("Encountered unhandled Type '%s' %s.", sort, sort.getKind()));
} catch (CVC5ApiException pE) {
pE.printStackTrace();
return null;
}
}
}
@SuppressWarnings("unchecked")
@Override
public <T extends Formula> T encapsulate(FormulaType<T> pType, Term pTerm) {
assert pType.equals(getFormulaType(pTerm))
|| (pType.equals(FormulaType.RationalType)
&& getFormulaType(pTerm).equals(FormulaType.IntegerType))
: String.format(
"Cannot encapsulate formula %s of Type %s as %s", pTerm, getFormulaType(pTerm), pType);
if (pType.isBooleanType()) {
return (T) new CVC5BooleanFormula(pTerm);
} else if (pType.isIntegerType()) {
return (T) new CVC5IntegerFormula(pTerm);
} else if (pType.isRationalType()) {
return (T) new CVC5RationalFormula(pTerm);
} else if (pType.isArrayType()) {
ArrayFormulaType<?, ?> arrFt = (ArrayFormulaType<?, ?>) pType;
return (T) new CVC5ArrayFormula<>(pTerm, arrFt.getIndexType(), arrFt.getElementType());
} else if (pType.isBitvectorType()) {
return (T) new CVC5BitvectorFormula(pTerm);
} else if (pType.isFloatingPointType()) {
return (T) new CVC5FloatingPointFormula(pTerm);
} else if (pType.isFloatingPointRoundingModeType()) {
return (T) new CVC5FloatingPointRoundingModeFormula(pTerm);
} else if (pType.isStringType()) {
return (T) new CVC5StringFormula(pTerm);
} else if (pType.isRegexType()) {
return (T) new CVC5RegexFormula(pTerm);
} else if (pType.isEnumerationType()) {
return (T) new CVC5EnumerationFormula(pTerm);
}
throw new IllegalArgumentException("Cannot create formulas of Type " + pType + " in CVC5");
}
private Formula encapsulate(Term pTerm) {
return encapsulate(getFormulaType(pTerm), pTerm);
}
@Override
public BooleanFormula encapsulateBoolean(Term pTerm) {
assert getFormulaType(pTerm).isBooleanType()
: String.format(
"%s is not boolean, but %s (%s)", pTerm, pTerm.getSort(), getFormulaType(pTerm));
return new CVC5BooleanFormula(pTerm);
}
@Override
public BitvectorFormula encapsulateBitvector(Term pTerm) {
assert getFormulaType(pTerm).isBitvectorType()
: String.format("%s is no BV, but %s (%s)", pTerm, pTerm.getSort(), getFormulaType(pTerm));
return new CVC5BitvectorFormula(pTerm);
}
@Override
protected FloatingPointFormula encapsulateFloatingPoint(Term pTerm) {
assert getFormulaType(pTerm).isFloatingPointType()
: String.format("%s is no FP, but %s (%s)", pTerm, pTerm.getSort(), getFormulaType(pTerm));
return new CVC5FloatingPointFormula(pTerm);
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TI extends Formula, TE extends Formula> ArrayFormula<TI, TE> encapsulateArray(
Term pTerm, FormulaType<TI> pIndexType, FormulaType<TE> pElementType) {
assert getFormulaType(pTerm).equals(FormulaType.getArrayType(pIndexType, pElementType))
: String.format(
"%s is no array, but %s (%s)", pTerm, pTerm.getSort(), getFormulaType(pTerm));
return new CVC5ArrayFormula<>(pTerm, pIndexType, pElementType);
}
@Override
protected StringFormula encapsulateString(Term pTerm) {
assert getFormulaType(pTerm).isStringType()
: String.format(
"%s is no String, but %s (%s)", pTerm, pTerm.getSort(), getFormulaType(pTerm));
return new CVC5StringFormula(pTerm);
}
@Override
protected RegexFormula encapsulateRegex(Term pTerm) {
assert getFormulaType(pTerm).isRegexType();
return new CVC5RegexFormula(pTerm);
}
@Override
protected EnumerationFormula encapsulateEnumeration(Term pTerm) {
assert getFormulaType(pTerm).isEnumerationType();
return new CVC5EnumerationFormula(pTerm);
}
private String getName(Term e) {
checkState(!e.isNull());
String repr = e.toString();
try {
if (e.getKind() == Kind.APPLY_UF) {
e = e.getChild(0);
}
} catch (CVC5ApiException e1) {
// Fallback is the String of the original term
}
if (e.hasSymbol()) {
return e.getSymbol();
} else if (repr.startsWith("(")) {
// Some function
// Functions are packaged like this: (functionName arg1 arg2 ...)
// But can use |(name)| to enable () inside of the variable name
// TODO what happens for function names containing whitepsace?
String dequoted = dequote(repr);
return Iterables.get(Splitter.on(' ').split(dequoted.substring(1)), 0);
} else {
return dequote(repr);
}
}
@Override
public <R> R visit(FormulaVisitor<R> visitor, Formula formula, final Term f) {
checkState(!f.isNull());
Sort sort = f.getSort();
try {
if (f.isBooleanValue()) {
return visitor.visitConstant(formula, f.getBooleanValue());
} else if (f.isStringValue()) {
return visitor.visitConstant(formula, f.getStringValue());
} else if (f.isRealValue()) {
Pair<BigInteger, BigInteger> realValue = f.getRealValue();
Object number =
BigInteger.ONE.equals(realValue.second)
? realValue.first
: Rational.of(realValue.first, realValue.second);
return visitor.visitConstant(formula, number);
} else if (f.isIntegerValue()) {
return visitor.visitConstant(formula, f.getIntegerValue());
} else if (f.isBitVectorValue()) {
return visitor.visitConstant(formula, new BigInteger(f.getBitVectorValue(), 2));
} else if (f.isFloatingPointValue()) {
// String is easier to parse here
return visitor.visitConstant(formula, f.toString());
} else if (f.getKind() == Kind.CONST_ROUNDINGMODE) {
return visitor.visitConstant(formula, f.toString());
} else if (f.getKind() == Kind.VARIABLE) {
// BOUND vars are used for all vars that are bound to a quantifier in CVC5.
// We resubstitute them back to the original free.
// CVC5 doesn't give you the de-brujin index
Term originalVar = variablesCache.get(dequote(formula.toString()));
return visitor.visitBoundVariable(encapsulate(originalVar), 0);
} else if (f.getKind() == Kind.FORALL || f.getKind() == Kind.EXISTS) {
// QUANTIFIER: replace bound variable with free variable for visitation
assert f.getNumChildren() == 2;
Term body = f.getChild(1);
List<Formula> freeVars = new ArrayList<>();
for (Term boundVar : f.getChild(0)) { // unpack grand-children of f.
String name = getName(boundVar);
Term freeVar = Preconditions.checkNotNull(variablesCache.get(name));
body = body.substitute(boundVar, freeVar);
freeVars.add(encapsulate(freeVar));
}
BooleanFormula fBody = encapsulateBoolean(body);
Quantifier quant = f.getKind() == Kind.EXISTS ? Quantifier.EXISTS : Quantifier.FORALL;
return visitor.visitQuantifier((BooleanFormula) formula, quant, freeVars, fBody);
} else if (f.getKind() == Kind.CONSTANT) {
return visitor.visitFreeVariable(formula, dequote(f.toString()));
} else if (f.getKind() == Kind.APPLY_CONSTRUCTOR) {
Preconditions.checkState(
f.getNumChildren() == 1, "Unexpected formula '%s' with sort '%s'", f, f.getSort());
return visitor.visitConstant(formula, f.getChild(0).getSymbol());
} else {
// Term expressions like uninterpreted function calls (Kind.APPLY_UF) or operators (e.g.
// Kind.AND).
// These are all treated like operators, so we can get the declaration by f.getOperator()!
ImmutableList.Builder<Formula> argsBuilder = ImmutableList.builder();
List<FormulaType<?>> argsTypes = new ArrayList<>();
// Term operator = normalize(f.getSort());
Kind kind = f.getKind();
if (sort.isFunction() || kind == Kind.APPLY_UF) {
// The arguments are all children except the first one
for (int i = 1; i < f.getNumChildren(); i++) {
argsTypes.add(getFormulaTypeFromTermType(f.getChild(i).getSort()));
// CVC5s first argument in a function/Uf is the declaration, we don't need that here
argsBuilder.add(encapsulate(f.getChild(i)));
}
} else {
for (Term arg : f) {
argsTypes.add(getFormulaType(arg));
argsBuilder.add(encapsulate(arg));
}
}
// TODO some operations (BV_SIGN_EXTEND, BV_ZERO_EXTEND, maybe more) encode information as
// part of the operator itself, thus the arity is one too small and there might be no
// possibility to access the information from user side. Should we encode such information
// as additional parameters? We do so for some methods of Princess.
if (sort.isFunction()) {
return visitor.visitFunction(
formula,
argsBuilder.build(),
FunctionDeclarationImpl.of(
getName(f), getDeclarationKind(f), argsTypes, getFormulaType(f), normalize(f)));
} else if (kind == Kind.APPLY_UF) {
return visitor.visitFunction(
formula,
argsBuilder.build(),
FunctionDeclarationImpl.of(
getName(f),
getDeclarationKind(f),
argsTypes,
getFormulaType(f),
normalize(f.getChild(0))));
} else {
// TODO: check if the below is correct
return visitor.visitFunction(
formula,
argsBuilder.build(),
FunctionDeclarationImpl.of(
getName(f), getDeclarationKind(f), argsTypes, getFormulaType(f), normalize(f)));
}
}
} catch (CVC5ApiException e) {
throw new IllegalArgumentException("Failure visiting the Term '" + f + "'.", e);
}
}
/**
* CVC5 returns new objects when querying operators for UFs. The new operator has to be translated
* back to a common one.
*/
private Term normalize(Term operator) {
Term function = functionsCache.get(getName(operator));
if (function != null) {
checkState(
function.getId() == operator.getId(),
"operator '%s' with ID %s differs from existing function '%s' with ID '%s'.",
operator,
operator.getId(),
function,
function.getId());
return function;
}
return operator;
}
// see src/theory/*/kinds in CVC5 sources for description of the different CVC5 kinds ;)
private static final ImmutableMap<Kind, FunctionDeclarationKind> KIND_MAPPING =
ImmutableMap.<Kind, FunctionDeclarationKind>builder()
.put(Kind.EQUAL, FunctionDeclarationKind.EQ)
.put(Kind.DISTINCT, FunctionDeclarationKind.DISTINCT)
.put(Kind.NOT, FunctionDeclarationKind.NOT)
.put(Kind.AND, FunctionDeclarationKind.AND)
.put(Kind.IMPLIES, FunctionDeclarationKind.IMPLIES)
.put(Kind.OR, FunctionDeclarationKind.OR)
.put(Kind.XOR, FunctionDeclarationKind.XOR)
.put(Kind.ITE, FunctionDeclarationKind.ITE)
.put(Kind.APPLY_UF, FunctionDeclarationKind.UF)
.put(Kind.ADD, FunctionDeclarationKind.ADD)
.put(Kind.MULT, FunctionDeclarationKind.MUL)
.put(Kind.SUB, FunctionDeclarationKind.SUB)
.put(Kind.INTS_MODULUS, FunctionDeclarationKind.MODULO)
.put(Kind.INTS_DIVISION, FunctionDeclarationKind.DIV)
.put(Kind.DIVISION, FunctionDeclarationKind.DIV)
.put(Kind.LT, FunctionDeclarationKind.LT)
.put(Kind.LEQ, FunctionDeclarationKind.LTE)
.put(Kind.GT, FunctionDeclarationKind.GT)
.put(Kind.GEQ, FunctionDeclarationKind.GTE)
// Bitvector theory
.put(Kind.BITVECTOR_ADD, FunctionDeclarationKind.BV_ADD)
.put(Kind.BITVECTOR_SUB, FunctionDeclarationKind.BV_SUB)
.put(Kind.BITVECTOR_MULT, FunctionDeclarationKind.BV_MUL)
.put(Kind.BITVECTOR_AND, FunctionDeclarationKind.BV_AND)
.put(Kind.BITVECTOR_OR, FunctionDeclarationKind.BV_OR)
.put(Kind.BITVECTOR_XOR, FunctionDeclarationKind.BV_XOR)
.put(Kind.BITVECTOR_SLT, FunctionDeclarationKind.BV_SLT)
.put(Kind.BITVECTOR_ULT, FunctionDeclarationKind.BV_ULT)
.put(Kind.BITVECTOR_SLE, FunctionDeclarationKind.BV_SLE)
.put(Kind.BITVECTOR_ULE, FunctionDeclarationKind.BV_ULE)
.put(Kind.BITVECTOR_SGT, FunctionDeclarationKind.BV_SGT)
.put(Kind.BITVECTOR_UGT, FunctionDeclarationKind.BV_UGT)
.put(Kind.BITVECTOR_SGE, FunctionDeclarationKind.BV_SGE)
.put(Kind.BITVECTOR_UGE, FunctionDeclarationKind.BV_UGE)
.put(Kind.BITVECTOR_SDIV, FunctionDeclarationKind.BV_SDIV)
.put(Kind.BITVECTOR_UDIV, FunctionDeclarationKind.BV_UDIV)
.put(Kind.BITVECTOR_SREM, FunctionDeclarationKind.BV_SREM)
// TODO: find out where Kind.BITVECTOR_SMOD fits in here
.put(Kind.BITVECTOR_UREM, FunctionDeclarationKind.BV_UREM)
.put(Kind.BITVECTOR_NOT, FunctionDeclarationKind.BV_NOT)
.put(Kind.BITVECTOR_NEG, FunctionDeclarationKind.BV_NEG)
.put(Kind.BITVECTOR_EXTRACT, FunctionDeclarationKind.BV_EXTRACT)
.put(Kind.BITVECTOR_CONCAT, FunctionDeclarationKind.BV_CONCAT)
.put(Kind.BITVECTOR_SIGN_EXTEND, FunctionDeclarationKind.BV_SIGN_EXTENSION)
.put(Kind.BITVECTOR_ZERO_EXTEND, FunctionDeclarationKind.BV_ZERO_EXTENSION)
.put(Kind.BITVECTOR_SHL, FunctionDeclarationKind.BV_SHL)
.put(Kind.BITVECTOR_ASHR, FunctionDeclarationKind.BV_ASHR)
.put(Kind.BITVECTOR_LSHR, FunctionDeclarationKind.BV_LSHR)
// Floating-point theory
.put(Kind.TO_INTEGER, FunctionDeclarationKind.FLOOR)
.put(Kind.TO_REAL, FunctionDeclarationKind.TO_REAL)
.put(Kind.FLOATINGPOINT_TO_SBV, FunctionDeclarationKind.FP_CASTTO_SBV)
.put(Kind.FLOATINGPOINT_TO_UBV, FunctionDeclarationKind.FP_CASTTO_UBV)
.put(Kind.FLOATINGPOINT_TO_FP_FROM_FP, FunctionDeclarationKind.FP_CASTTO_FP)
.put(Kind.FLOATINGPOINT_TO_FP_FROM_SBV, FunctionDeclarationKind.BV_SCASTTO_FP)
.put(Kind.FLOATINGPOINT_TO_FP_FROM_UBV, FunctionDeclarationKind.BV_UCASTTO_FP)
.put(Kind.FLOATINGPOINT_IS_NAN, FunctionDeclarationKind.FP_IS_NAN)
.put(Kind.FLOATINGPOINT_IS_NEG, FunctionDeclarationKind.FP_IS_NEGATIVE)
.put(Kind.FLOATINGPOINT_IS_INF, FunctionDeclarationKind.FP_IS_INF)
.put(Kind.FLOATINGPOINT_IS_NORMAL, FunctionDeclarationKind.FP_IS_NORMAL)
.put(Kind.FLOATINGPOINT_IS_SUBNORMAL, FunctionDeclarationKind.FP_IS_SUBNORMAL)
.put(Kind.FLOATINGPOINT_IS_ZERO, FunctionDeclarationKind.FP_IS_ZERO)
.put(Kind.FLOATINGPOINT_EQ, FunctionDeclarationKind.FP_EQ)
.put(Kind.FLOATINGPOINT_ABS, FunctionDeclarationKind.FP_ABS)
.put(Kind.FLOATINGPOINT_MAX, FunctionDeclarationKind.FP_MAX)
.put(Kind.FLOATINGPOINT_MIN, FunctionDeclarationKind.FP_MIN)
.put(Kind.FLOATINGPOINT_SQRT, FunctionDeclarationKind.FP_SQRT)
.put(Kind.FLOATINGPOINT_ADD, FunctionDeclarationKind.FP_ADD)
.put(Kind.FLOATINGPOINT_SUB, FunctionDeclarationKind.FP_SUB)
.put(Kind.FLOATINGPOINT_MULT, FunctionDeclarationKind.FP_MUL)
.put(Kind.FLOATINGPOINT_DIV, FunctionDeclarationKind.FP_DIV)
.put(Kind.FLOATINGPOINT_NEG, FunctionDeclarationKind.FP_NEG)
.put(Kind.FLOATINGPOINT_LT, FunctionDeclarationKind.FP_LT)
.put(Kind.FLOATINGPOINT_LEQ, FunctionDeclarationKind.FP_LE)
.put(Kind.FLOATINGPOINT_GT, FunctionDeclarationKind.FP_GT)
.put(Kind.FLOATINGPOINT_GEQ, FunctionDeclarationKind.FP_GE)
.put(Kind.FLOATINGPOINT_RTI, FunctionDeclarationKind.FP_ROUND_TO_INTEGRAL)
.put(Kind.FLOATINGPOINT_TO_FP_FROM_IEEE_BV, FunctionDeclarationKind.FP_FROM_IEEEBV)
// String and Regex theory
.put(Kind.STRING_CONCAT, FunctionDeclarationKind.STR_CONCAT)
.put(Kind.STRING_PREFIX, FunctionDeclarationKind.STR_PREFIX)
.put(Kind.STRING_SUFFIX, FunctionDeclarationKind.STR_SUFFIX)
.put(Kind.STRING_CONTAINS, FunctionDeclarationKind.STR_CONTAINS)
.put(Kind.STRING_SUBSTR, FunctionDeclarationKind.STR_SUBSTRING)
.put(Kind.STRING_REPLACE, FunctionDeclarationKind.STR_REPLACE)
.put(Kind.STRING_REPLACE_ALL, FunctionDeclarationKind.STR_REPLACE_ALL)
.put(Kind.STRING_CHARAT, FunctionDeclarationKind.STR_CHAR_AT)
.put(Kind.STRING_LENGTH, FunctionDeclarationKind.STR_LENGTH)
.put(Kind.STRING_INDEXOF, FunctionDeclarationKind.STR_INDEX_OF)
.put(Kind.STRING_TO_REGEXP, FunctionDeclarationKind.STR_TO_RE)
.put(Kind.STRING_IN_REGEXP, FunctionDeclarationKind.STR_IN_RE)
.put(Kind.STRING_FROM_INT, FunctionDeclarationKind.INT_TO_STR)
.put(Kind.STRING_TO_INT, FunctionDeclarationKind.STR_TO_INT)
.put(Kind.STRING_LT, FunctionDeclarationKind.STR_LT)
.put(Kind.STRING_LEQ, FunctionDeclarationKind.STR_LE)
.put(Kind.REGEXP_PLUS, FunctionDeclarationKind.RE_PLUS)
.put(Kind.REGEXP_STAR, FunctionDeclarationKind.RE_STAR)
.put(Kind.REGEXP_OPT, FunctionDeclarationKind.RE_OPTIONAL)
.put(Kind.REGEXP_CONCAT, FunctionDeclarationKind.RE_CONCAT)
.put(Kind.REGEXP_UNION, FunctionDeclarationKind.RE_UNION)
.put(Kind.REGEXP_RANGE, FunctionDeclarationKind.RE_RANGE)
.put(Kind.REGEXP_INTER, FunctionDeclarationKind.RE_INTERSECT)
.put(Kind.REGEXP_COMPLEMENT, FunctionDeclarationKind.RE_COMPLEMENT)
.put(Kind.REGEXP_DIFF, FunctionDeclarationKind.RE_DIFFERENCE)
.build();
private FunctionDeclarationKind getDeclarationKind(Term f) {
try {
Kind kind = f.getKind();
// special case: IFF for Boolean, EQ for all other Types
if (kind == Kind.EQUAL && Iterables.all(f, child -> child.getSort().isBoolean())) {
return FunctionDeclarationKind.IFF;
}
return KIND_MAPPING.getOrDefault(kind, FunctionDeclarationKind.OTHER);
} catch (CVC5ApiException e) {
throw new IllegalArgumentException("Failure trying to get the KIND of Term '" + f + "'.", e);
}
}
@Override
protected Term getBooleanVarDeclarationImpl(Term pTFormulaInfo) {
try {
Kind kind = pTFormulaInfo.getKind();
// CONSTANTS are "variables" and Kind.VARIABLEs are bound variables in for example quantifiers
assert kind == Kind.APPLY_UF || kind == Kind.CONSTANT : pTFormulaInfo.getKind();
if (kind == Kind.APPLY_UF) {
// TODO: Test this, this is the old internal implementation
return pTFormulaInfo.getChild(0);
// old
// return pTFormulaInfo.getOperator();
} else {
return pTFormulaInfo;
}
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"You tried reading a bool variable potentially in a UF application that failed. Checked"
+ " term: "
+ pTFormulaInfo
+ ".",
e);
}
}
@Override
public Term callFunctionImpl(final Term pDeclaration, final List<Term> pArgs) {
if (pArgs.isEmpty()) {
// CVC5 does not allow argumentless functions! We use variables as a workaround.
return pDeclaration;
} else {
if (pDeclaration.hasOp()) {
Op op = pDeclaration.getOp();
return solver.mkTerm(op, pArgs.toArray(new Term[] {}));
} else {
try {
Sort[] paramSorts = pDeclaration.getSort().getFunctionDomainSorts();
List<Term> args = castToParamTypeIfRequired(pArgs, paramSorts);
Kind kind = pDeclaration.getKind();
if (kind == Kind.CONSTANT) {
// For UF application, we need the declaration of the UF as first argument!
kind = Kind.APPLY_UF;
args.add(0, pDeclaration);
}
return solver.mkTerm(kind, args.toArray(new Term[] {}));
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"Failure when building the UF '"
+ pDeclaration
+ "'"
+ " with arguments '"
+ pArgs
+ "'.",
e);
}
}
}
}
/**
* CVC5 does not allow subtyping for INT and REAL/RATIONAL, but requires a cast. This method
* inserts a cast, if required by the parameter type.
*
* @param pArgs input arguments to be casted.
* @param pParamSorts target type for all arguments.
* @return a list of potentially casted arguments.
*/
private List<Term> castToParamTypeIfRequired(List<Term> pArgs, Sort[] pParamSorts) {
final List<Term> args = new ArrayList<>();
for (int i = 0; i < pArgs.size(); i++) {
args.add(
castToParamTypeIfRequired(pArgs.get(i), pParamSorts.length > i ? pParamSorts[i] : null));
}
return args;
}
private Term castToParamTypeIfRequired(Term input, @Nullable Sort targetSort) {
if (input.getSort().isInteger() && targetSort.isReal()) {
return solver.mkTerm(Kind.TO_REAL, input);
}
return input;
}
/**
* Check that the symbol does not contain characters that CVC5 interpretes as SMTLIB2 commands.
*
* @param symbol the symbol to check
* @throws IllegalArgumentException if symbol can not be used with CVC5.
*/
private void checkSymbol(String symbol) {
checkArgument(
!UNSUPPORTED_IDENTIFIERS.contains(symbol),
"CVC5 does not support %s as identifier.",
symbol);
}
@Override
public Term declareUFImpl(String pName, Sort pReturnType, List<Sort> pArgTypes) {
checkSymbol(pName);
Term exp = functionsCache.get(pName);
if (exp == null) {
// Ufs in CVC5 can't have 0 arity. We just use a variable as a workaround.
Sort sort =
pArgTypes.isEmpty()
? pReturnType
: solver.mkFunctionSort(pArgTypes.toArray(new Sort[0]), pReturnType);
exp = solver.mkConst(sort, pName);
functionsCache.put(pName, exp);
} else {
Preconditions.checkArgument(
exp.getSort().equals(exp.getSort()),
"Symbol %s already in use for different return type %s",
exp,
exp.getSort());
for (int i = 1; i < exp.getNumChildren(); i++) {
// CVC5s first argument in a function/Uf is the declaration, we don't need that here
try {
Preconditions.checkArgument(
pArgTypes.get(i).equals(exp.getChild(i).getSort()),
"Argument %s with type %s does not match expected type %s",
i - 1,
pArgTypes.get(i),
exp.getChild(i).getSort());
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"Failure visiting the Term '" + exp + "' at index " + i + ".", e);
}
}
}
return exp;
}
@Override
public Object convertValue(Term expForType, Term value) {
final Sort type = expForType.getSort();
final Sort valueType = value.getSort();
// Variables are Kind.CONSTANT and can't be check with isIntegerValue() or getIntegerValue()
// etc. but only with solver.getValue() and its String serialization
try {
if (value.getKind() == Kind.VARIABLE) {
// VARIABLE == bound variables
// CVC5 does not allow model values for bound vars; just return the name
return value.getSymbol();
} else if (value.isIntegerValue() && type.isInteger()) {
return value.getIntegerValue();
} else if (value.isRealValue()) {
Pair<BigInteger, BigInteger> realValue = value.getRealValue();
Rational ratValue = Rational.of(realValue.first, realValue.second);
return ratValue.isIntegral() ? ratValue.getNum() : ratValue;
} else if (value.isBitVectorValue()) {
String bitvectorValue = value.getBitVectorValue();
return new BigInteger(bitvectorValue, 2);
} else if (value.isFloatingPointNaN()) {
return Float.NaN;
} else if (value.isFloatingPointNegInf()) {
return Float.NEGATIVE_INFINITY;
} else if (value.isFloatingPointPosInf()) {
return Float.POSITIVE_INFINITY;
} else if (value.isFloatingPointPosZero()) {
return BigDecimal.ZERO;
} else if (value.isFloatingPointValue()) {
// Negative zero falls under this category
// String valueString =
// solver.getValue(solver.mkTerm(Kind.FLOATINGPOINT_TO_REAL, fpTerm)).toString();
// return new BigDecimal(valueString).stripTrailingZeros();
final Triplet<Long, Long, Term> fpValue = value.getFloatingPointValue();
final long expWidth = fpValue.first;
final long mantWidth = fpValue.second - 1; // CVC5 also counts the sign-bit in the mantissa
final Term bvValue = fpValue.third;
Preconditions.checkState(bvValue.isBitVectorValue());
BigInteger bits = new BigInteger(bvValue.getBitVectorValue(), 2);
if (expWidth == 11 && mantWidth == 52) { // standard IEEE double type with 64 bits
return Double.longBitsToDouble(bits.longValue());
} else if (expWidth == 8 && mantWidth == 23) { // standard IEEE float type with 32 bits
return Float.intBitsToFloat(bits.intValue());
} else {
// TODO to be fully correct, we would need to interpret the BV as FP or Rational
return value.toString(); // returns a BV representation of the FP
}
} else if (value.isBooleanValue()) {
return value.getBooleanValue();
} else if (value.isStringValue()) {
return value.getStringValue();
} else {
// String serialization for Strings and unknown terms.
return value.toString();
}
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
String.format(
"Failure trying to convert constant %s with type %s to type %s.",
value, valueType, type),
e);
}
}
}
| 35,562 | 41.692677 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5FormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import com.google.common.base.Joiner;
import com.google.common.collect.Iterables;
import de.uni_freiburg.informatik.ultimate.logic.PrintTerm;
import io.github.cvc5.CVC5ApiException;
import io.github.cvc5.Kind;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.Map;
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.api.FormulaType;
import org.sosy_lab.java_smt.basicimpl.AbstractFormulaManager;
class CVC5FormulaManager extends AbstractFormulaManager<Term, Sort, Solver, Term> {
private final CVC5FormulaCreator creator;
@SuppressWarnings("checkstyle:parameternumber")
CVC5FormulaManager(
CVC5FormulaCreator pFormulaCreator,
CVC5UFManager pFfmgr,
CVC5BooleanFormulaManager pBfmgr,
CVC5IntegerFormulaManager pIfmgr,
CVC5RationalFormulaManager pRfmgr,
CVC5BitvectorFormulaManager pBvfmgr,
CVC5FloatingPointFormulaManager pFpfmgr,
CVC5QuantifiedFormulaManager pQfmgr,
CVC5ArrayFormulaManager pAfmgr,
CVC5SLFormulaManager pSLfmgr,
CVC5StringFormulaManager pStrmgr,
CVC5EnumerationFormulaManager pEfmgr) {
super(
pFormulaCreator,
pFfmgr,
pBfmgr,
pIfmgr,
pRfmgr,
pBvfmgr,
pFpfmgr,
pQfmgr,
pAfmgr,
pSLfmgr,
pStrmgr,
pEfmgr);
creator = pFormulaCreator;
}
static Term getCVC5Term(Formula pT) {
if (pT instanceof CVC5Formula) {
return ((CVC5Formula) pT).getTerm();
}
throw new IllegalArgumentException(
"Cannot get the formula info of type " + pT.getClass().getSimpleName() + " in the Solver!");
}
@Override
public BooleanFormula parse(String pS) throws IllegalArgumentException {
throw new UnsupportedOperationException();
}
@Override
public Appender dumpFormula(Term f) {
assert getFormulaCreator().getFormulaType(f) == FormulaType.BooleanType
: "Only BooleanFormulas may be dumped";
return new Appenders.AbstractAppender() {
@Override
public void appendTo(Appendable out) throws IOException {
// get all symbols
final Map<String, Term> allVars = new LinkedHashMap<>();
creator.extractVariablesAndUFs(f, true, allVars::put);
// print all symbols
for (Map.Entry<String, Term> entry : allVars.entrySet()) {
String name = entry.getKey();
Term var = entry.getValue();
// escaping is stolen from SMTInterpol, lets hope this remains consistent
out.append("(declare-fun ").append(PrintTerm.quoteIdentifier(name)).append(" (");
// add function parameters
Iterable<Sort> childrenTypes;
try {
if (var.getSort().isFunction() || var.getKind() == Kind.APPLY_UF) {
childrenTypes = Iterables.skip(Iterables.transform(var, Term::getSort), 1);
} else {
childrenTypes = Iterables.transform(var, Term::getSort);
}
} catch (CVC5ApiException e) {
childrenTypes = Iterables.transform(var, Term::getSort);
}
out.append(Joiner.on(" ").join(childrenTypes));
// and return type
out.append(") ").append(var.getSort().toString()).append(")\n");
}
// now add the final assert
out.append("(assert ");
// Formerly in CVC4:
// f.toString() does expand all nested sub-expressions and causes exponential overhead.
// f.toStream() uses LET-expressions and is exactly what we want.
// However, in CVC5 toStream() does no longer exists.
// TODO: either toString() will do, or we may need iterator().
/*
try (OutputStream stream =
new OutputStream() {
@Override
public void write(int chr) throws IOException {
out.append((char) chr);
}
}) {
f.toStream(stream);
}
*/
out.append(f.toString());
out.append(')');
}
};
}
@Override
public <T extends Formula> T substitute(
final T pF, final Map<? extends Formula, ? extends Formula> pFromToMapping) {
Term termThatGetsSubst = extractInfo(pF);
Term[] toBeSubstituted = new Term[pFromToMapping.size()];
Term[] substitutes = new Term[pFromToMapping.size()];
int i = 0;
for (Map.Entry<? extends Formula, ? extends Formula> e : pFromToMapping.entrySet()) {
toBeSubstituted[i] = extractInfo(e.getKey());
substitutes[i] = extractInfo(e.getValue());
i++;
}
// CVC5 stops after the first term is replaced, rerun until nothing changes
boolean matches = false;
while (!matches) {
Term newTerm = termThatGetsSubst.substitute(toBeSubstituted, substitutes);
matches = termThatGetsSubst.equals(newTerm);
termThatGetsSubst = newTerm;
}
FormulaType<T> type = getFormulaType(pF);
return getFormulaCreator().encapsulate(type, termThatGetsSubst);
}
}
| 5,492 | 32.699387 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5IntegerFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import io.github.cvc5.CVC5ApiException;
import io.github.cvc5.Kind;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import java.math.BigDecimal;
import java.math.BigInteger;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
public class CVC5IntegerFormulaManager
extends CVC5NumeralFormulaManager<IntegerFormula, IntegerFormula>
implements IntegerFormulaManager {
CVC5IntegerFormulaManager(CVC5FormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
}
@Override
protected Sort getNumeralType() {
return getFormulaCreator().getIntegerType();
}
@Override
protected Term makeNumberImpl(double pNumber) {
return makeNumberImpl((long) pNumber);
}
@Override
protected Term makeNumberImpl(BigDecimal pNumber) {
return decimalAsInteger(pNumber);
}
@Override
public Term divide(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.INTS_DIVISION, pParam1, pParam2);
}
@Override
protected Term modularCongruence(Term pNumber1, Term pNumber2, long pModulo) {
return modularCongruence(pNumber1, pNumber2, BigInteger.valueOf(pModulo));
}
@Override
protected Term modularCongruence(Term pNumber1, Term pNumber2, BigInteger pModulo) {
// ((_ divisible n) x) <==> (= x (* n (div x n)))
if (BigInteger.ZERO.compareTo(pModulo) < 0) {
Term n = makeNumberImpl(pModulo);
Term x = subtract(pNumber1, pNumber2);
return solver.mkTerm(
Kind.EQUAL, x, solver.mkTerm(Kind.MULT, n, solver.mkTerm(Kind.INTS_DIVISION, x, n)));
}
return solver.mkBoolean(true);
}
@Override
protected Term makeNumberImpl(BigInteger pI) {
return makeNumberImpl(pI.toString());
}
@Override
protected Term makeNumberImpl(String pI) {
if (!INTEGER_NUMBER.matcher(pI).matches()) {
throw new NumberFormatException("Number is not an integer value: " + pI);
}
try {
return solver.mkInteger(pI);
} catch (CVC5ApiException e) {
throw new NumberFormatException("Number is not an integer value: " + pI);
}
}
@Override
protected Term makeVariableImpl(String pI) {
return formulaCreator.makeVariable(getFormulaCreator().getIntegerType(), pI);
}
}
| 2,596 | 28.850575 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5Model.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import io.github.cvc5.CVC5ApiException;
import io.github.cvc5.Kind;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import java.util.Collection;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.FormulaManager;
import org.sosy_lab.java_smt.basicimpl.AbstractModel;
public class CVC5Model extends AbstractModel<Term, Sort, Solver> {
private final ImmutableList<ValueAssignment> model;
private final Solver solver;
private final ImmutableList<Term> assertedExpressions;
@SuppressWarnings("unused")
private final FormulaManager mgr;
CVC5Model(
CVC5AbstractProver<?> pProver,
FormulaManager pMgr,
CVC5FormulaCreator pCreator,
Collection<Term> pAssertedExpressions) {
super(pProver, pCreator);
solver = pProver.solver;
mgr = pMgr;
assertedExpressions = ImmutableList.copyOf(pAssertedExpressions);
// We need to generate and save this at construction time as CVC4 has no functionality to give a
// persistent reference to the model. If the SMT engine is used somewhere else, the values we
// get out of it might change!
model = generateModel();
}
@Override
public Term evalImpl(Term f) {
Preconditions.checkState(!isClosed());
return solver.getValue(f);
}
private ImmutableList<ValueAssignment> generateModel() {
ImmutableSet.Builder<ValueAssignment> builder = ImmutableSet.builder();
// Using creator.extractVariablesAndUFs we wouldn't get accurate information anymore as we
// translate all bound vars back to their free counterparts in the visitor!
for (Term expr : assertedExpressions) {
// creator.extractVariablesAndUFs(expr, true, (name, f) -> builder.add(getAssignment(f)));
recursiveAssignmentFinder(builder, expr);
}
return builder.build().asList();
}
// TODO this method is highly recursive and should be rewritten with a proper visitor
private void recursiveAssignmentFinder(ImmutableSet.Builder<ValueAssignment> builder, Term expr) {
try {
Sort sort = expr.getSort();
Kind kind = expr.getKind();
if (kind == Kind.VARIABLE || sort.isFunction()) {
// We don't care about functions, as thats just the function definition and the nested
// lambda term
// We don't care about bound vars (not in a UF), as they don't return a value.
return;
} else if (kind == Kind.CONSTANT) {
// Vars and UFs, as well as bound vars in UFs!
// In CVC5 consts are variables! Free variables (in CVC5s notation, we call them bound
// variables, created with mkVar() can never have a value!)
builder.add(getAssignment(expr));
} else if (kind == Kind.FORALL || kind == Kind.EXISTS) {
// Body of the quantifier, with bound vars!
Term body = expr.getChild(1);
recursiveAssignmentFinder(builder, body);
} else if (kind == Kind.CONST_STRING
|| kind == Kind.CONST_ARRAY
|| kind == Kind.CONST_BITVECTOR
|| kind == Kind.CONST_BOOLEAN
|| kind == Kind.CONST_FLOATINGPOINT
|| kind == Kind.CONST_RATIONAL
|| kind == Kind.CONST_ROUNDINGMODE
|| kind == Kind.CONST_SEQUENCE) {
// Constants, do nothing
} else if (kind == Kind.APPLY_UF) {
builder.add(getAssignmentForUf(expr));
} else {
// Only nested terms (AND, OR, ...) are left
for (Term child : expr) {
recursiveAssignmentFinder(builder, child);
}
}
} catch (CVC5ApiException e) {
throw new IllegalArgumentException("Failure visiting the Term '" + expr + "'.", e);
}
}
private ValueAssignment getAssignmentForUf(Term pKeyTerm) {
// Ufs consist of arguments + 1 child, the first child is the function definition as a lambda
// and the result, while the remaining children are the arguments. Note: we can't evaluate bound
// variables!
ImmutableList.Builder<Object> argumentInterpretationBuilder = ImmutableList.builder();
boolean boundFound = false;
// We don't want the first argument of uf applications as it is the declaration
for (int i = 1; i < pKeyTerm.getNumChildren(); i++) {
try {
Term child = pKeyTerm.getChild(i);
if (child.getKind().equals(Kind.VARIABLE)) {
// Remember if we encountered bound variables
boundFound = true;
// Bound vars are extremely volatile in CVC5. Nearly every call to them ends in an
// exception. Also we don't want to substitute them with their non bound values.
argumentInterpretationBuilder.add(child.toString());
} else {
argumentInterpretationBuilder.add(evaluateImpl(child));
}
} catch (CVC5ApiException e) {
throw new IllegalArgumentException("Failure visiting the Term '" + pKeyTerm + "'.", e);
}
}
// In applied UFs the child with the name is the 0th child (as it is the declaration)
String nameStr;
try {
nameStr = pKeyTerm.getChild(0).getSymbol();
} catch (CVC5ApiException e) {
nameStr = "UF";
}
if (nameStr.startsWith("|") && nameStr.endsWith("|")) {
nameStr = nameStr.substring(1, nameStr.length() - 1);
}
Term valueTerm;
// You can't get a value if there is a bound variable present
if (!boundFound) {
valueTerm = solver.getValue(pKeyTerm);
} else {
// But you may be able to get one nested in the function itself for some reason
try {
valueTerm = solver.getValue(pKeyTerm.getChild(0)).getChild(1);
} catch (CVC5ApiException e) {
throw new IndexOutOfBoundsException(
"Accessed a non existing UF value while creating a CVC5 model.");
}
}
Formula keyFormula = creator.encapsulateWithTypeOf(pKeyTerm);
Formula valueFormula = creator.encapsulateWithTypeOf(valueTerm);
BooleanFormula equation =
creator.encapsulateBoolean(solver.mkTerm(Kind.EQUAL, pKeyTerm, valueTerm));
Object value = creator.convertValue(pKeyTerm, valueTerm);
return new ValueAssignment(
keyFormula, valueFormula, equation, nameStr, value, argumentInterpretationBuilder.build());
}
private ValueAssignment getAssignment(Term pKeyTerm) {
ImmutableList.Builder<Object> argumentInterpretationBuilder = ImmutableList.builder();
for (int i = 0; i < pKeyTerm.getNumChildren(); i++) {
try {
argumentInterpretationBuilder.add(evaluateImpl(pKeyTerm.getChild(i)));
} catch (CVC5ApiException e) {
throw new IndexOutOfBoundsException(
"Accessed a non existing UF value while creating a CVC5 model.");
}
}
String nameStr = "";
if (pKeyTerm.hasSymbol()) {
nameStr = pKeyTerm.getSymbol();
} else {
// Default if there is no name
nameStr = "UNKNOWN_VARIABLE";
}
if (nameStr.startsWith("|") && nameStr.endsWith("|")) {
nameStr = nameStr.substring(1, nameStr.length() - 1);
}
Term valueTerm = solver.getValue(pKeyTerm);
Formula keyFormula = creator.encapsulateWithTypeOf(pKeyTerm);
Formula valueFormula = creator.encapsulateWithTypeOf(valueTerm);
BooleanFormula equation =
creator.encapsulateBoolean(solver.mkTerm(Kind.EQUAL, pKeyTerm, valueTerm));
Object value = creator.convertValue(pKeyTerm, valueTerm);
return new ValueAssignment(
keyFormula, valueFormula, equation, nameStr, value, argumentInterpretationBuilder.build());
}
@Override
public ImmutableList<ValueAssignment> asList() {
return model;
}
}
| 8,061 | 37.94686 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5NativeAPITest.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2021 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertThrows;
import com.google.common.base.Preconditions;
import io.github.cvc5.CVC5ApiException;
import io.github.cvc5.Kind;
import io.github.cvc5.Op;
import io.github.cvc5.Result;
import io.github.cvc5.RoundingMode;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
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;
/*
* Please note that CVC5 does not have a native variable cache!
* Each variable created is a new one with a new internal id, even if they are named the same.
* As a result, checking equality on 2 formulas that are build with new variables
* that are named the same results in false!
* Additionally, CVC5 only supports quantifier elimination for LIA and LRA.
* However, it might run endlessly in some cases if you try quantifier elimination on array
* theories!
*/
public class CVC5NativeAPITest {
private static final String INVALID_GETVALUE_STRING_SAT =
"Cannot get value unless after a SAT or UNKNOWN response.";
private static final String INVALID_TERM_BOUND_VAR =
"Cannot process term .* with free variables: .*";
private static final String INVALID_MODEL_STRING =
"Cannot get model unless after a SAT or UNKNOWN response.";
@BeforeClass
public static void loadCVC5() {
try {
CVC5SolverContext.loadLibrary(NativeLibraries::loadLibrary);
} catch (UnsatisfiedLinkError e) {
throw new AssumptionViolatedException("CVC5 is not available", e);
}
}
private Term x;
private Term array;
private Term aAtxEq0;
private Term aAtxEq1;
private Solver solver;
@Before
public void init() throws CVC5ApiException {
solver = createEnvironment();
}
private static Solver createEnvironment() throws CVC5ApiException {
Solver newSolver = new Solver();
newSolver.setLogic("ALL");
// options
newSolver.setOption("incremental", "true");
newSolver.setOption("produce-models", "true");
newSolver.setOption("finite-model-find", "true");
newSolver.setOption("sets-ext", "true");
newSolver.setOption("output-language", "smtlib2");
newSolver.setOption("strings-exp", "true");
return newSolver;
}
@After
public void freeEnvironment() {
solver.deletePointer();
}
/*
* Check how to get types/values etc. from constants, variables etc. in CVC5.
* You can get the values of constants via toString()
* and the name of variables via toString().
* One can use getOp() on a Term to get its operator.
* This operator can be used to create the same Term again with the same arguments.
* The Ids match.
*/
@Test
public void checkGetValueAndType() throws CVC5ApiException {
// Constant values (NOT Kind,CONSTANT!)
assertThat(solver.mkBoolean(false).isBooleanValue()).isTrue();
assertThat(solver.mkInteger(0).isIntegerValue()).isTrue();
assertThat(solver.mkInteger(999).isIntegerValue()).isTrue();
assertThat(solver.mkInteger(-1).isIntegerValue()).isTrue();
assertThat(solver.mkInteger("0").isIntegerValue()).isTrue();
assertThat(solver.mkString("").isStringValue()).isTrue();
// Note: toString on String values does not equal the value!!
assertThat(solver.mkString("").toString()).isNotEqualTo("");
assertThat(solver.mkString("").getStringValue()).isEqualTo("");
// Variables (named const, because thats not confusing....)
// Variables (Consts) return false if checked for value!
assertThat(solver.mkConst(solver.getBooleanSort()).isBooleanValue()).isFalse();
assertThat(solver.mkConst(solver.getIntegerSort()).isIntegerValue()).isFalse();
// To check for variables we have to check for value and type
assertThat(solver.mkConst(solver.getBooleanSort()).getSort().isBoolean()).isTrue();
// Test consts (variables). Consts are always false when checked for isTypedValue(), if you try
// getTypedValue() on it anyway an exception is raised. This persists after sat. The only way of
// checking and geting the values is via Kind.CONSTANT, type = sort and getValue()
Term intVar = solver.mkConst(solver.getIntegerSort(), "int_const");
assertThat(intVar.isIntegerValue()).isFalse();
assertThat(intVar.getSort().isInteger()).isTrue();
Exception e = assertThrows(io.github.cvc5.CVC5ApiException.class, intVar::getIntegerValue);
assertThat(e.toString())
.contains(
"Invalid argument 'int_const' for '*d_node', expected Term to be an integer value when"
+ " calling getIntegerValue()");
// Build a formula such that is has a value, assert and check sat and then check again
Term equality = solver.mkTerm(Kind.EQUAL, intVar, solver.mkInteger(1));
solver.assertFormula(equality);
// Is sat, no need to check
solver.checkSat();
assertThat(intVar.isIntegerValue()).isFalse();
assertThat(intVar.getSort().isInteger()).isTrue();
assertThat(intVar.getKind()).isEqualTo(Kind.CONSTANT);
assertThat(intVar.getKind()).isNotEqualTo(Kind.VARIABLE);
assertThat(solver.getValue(intVar).toString()).isEqualTo("1");
// Op test
assertThat(equality.getOp().toString()).isEqualTo("EQUAL");
assertThat(
solver.mkTerm(equality.getOp(), intVar, solver.mkInteger(1)).getId()
== equality.getId())
.isTrue();
// Note that variables (Kind.VARIABLES) are bound variables!
assertThat(solver.mkVar(solver.getIntegerSort()).getKind()).isEqualTo(Kind.VARIABLE);
assertThat(solver.mkVar(solver.getIntegerSort()).getKind()).isNotEqualTo(Kind.CONSTANT);
// Uf return sort is codomain
// Uf unapplied are CONSTANT
Sort intToBoolSort = solver.mkFunctionSort(solver.getIntegerSort(), solver.getBooleanSort());
assertThat(intToBoolSort.getFunctionCodomainSort().isBoolean()).isTrue();
Term uf1 = solver.mkConst(intToBoolSort);
assertThat(uf1.getKind()).isNotEqualTo(Kind.VARIABLE);
assertThat(uf1.getKind()).isEqualTo(Kind.CONSTANT);
assertThat(uf1.getKind()).isNotEqualTo(Kind.APPLY_UF);
assertThat(intToBoolSort.isFunction()).isTrue();
assertThat(uf1.getSort().isFunction()).isTrue();
// arity 1
assertThat(uf1.getSort().getFunctionArity()).isEqualTo(1);
// apply the uf, the kind is now APPLY_UF
Term appliedUf1 = solver.mkTerm(Kind.APPLY_UF, new Term[] {uf1, intVar});
assertThat(appliedUf1.getKind()).isNotEqualTo(Kind.VARIABLE);
assertThat(appliedUf1.getKind()).isNotEqualTo(Kind.CONSTANT);
assertThat(appliedUf1.getKind()).isEqualTo(Kind.APPLY_UF);
assertThat(appliedUf1.getSort().isFunction()).isFalse();
// The ufs sort is always the returntype
assertThat(appliedUf1.getSort()).isEqualTo(solver.getBooleanSort());
assertThat(appliedUf1.getNumChildren()).isEqualTo(2);
// The first child is the UF
assertThat(appliedUf1.getChild(0).getSort()).isEqualTo(intToBoolSort);
// The second child onwards are the arguments
assertThat(appliedUf1.getChild(1).getSort()).isEqualTo(solver.getIntegerSort());
}
/*
* Try to convert real -> int -> bv -> fp; which fails at the fp step.
* Use Kind.FLOATINGPOINT_TO_FP_REAL instead!
*/
@Test
public void checkFPConversion() throws CVC5ApiException {
Term oneFourth = solver.mkReal("1/4");
Term intOneFourth = solver.mkTerm(Kind.TO_INTEGER, oneFourth);
Term bvOneFourth = solver.mkTerm(solver.mkOp(Kind.INT_TO_BITVECTOR, 32), intOneFourth);
Exception e =
assertThrows(
io.github.cvc5.CVC5ApiException.class,
() -> solver.mkFloatingPoint(8, 24, bvOneFourth));
assertThat(e.toString())
.contains(
"Invalid argument '((_ int2bv 32) (to_int (/ 1 4)))' for 'val', expected bit-vector"
+ " constant");
}
@Test
public void checkSimpleUnsat() {
solver.assertFormula(solver.mkBoolean(false));
Result satCheck = solver.checkSat();
assertThat(satCheck.isUnsat()).isTrue();
}
@Test
public void checkSimpleSat() {
solver.assertFormula(solver.mkBoolean(true));
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
}
@Test
public void checkSimpleEqualitySat() {
Term one = solver.mkInteger(1);
Term assertion = solver.mkTerm(Kind.EQUAL, one, one);
solver.assertFormula(assertion);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
}
@Test
public void checkSimpleEqualityUnsat() {
Term zero = solver.mkInteger(0);
Term one = solver.mkInteger(1);
Term assertion = solver.mkTerm(Kind.EQUAL, zero, one);
solver.assertFormula(assertion);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
}
@Test
public void checkSimpleInequalityUnsat() {
Term one = solver.mkInteger(1);
Term assertion = solver.mkTerm(Kind.NOT, solver.mkTerm(Kind.EQUAL, one, one));
solver.assertFormula(assertion);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
}
@Test
public void checkSimpleInequalitySat() {
Term zero = solver.mkInteger(0);
Term one = solver.mkInteger(1);
Term assertion = solver.mkTerm(Kind.NOT, solver.mkTerm(Kind.EQUAL, zero, one));
solver.assertFormula(assertion);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
}
@Test
public void checkSimpleLIAEqualitySat() {
Term one = solver.mkInteger(1);
Term two = solver.mkInteger(2);
Term assertion = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.ADD, one, one), two);
solver.assertFormula(assertion);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
}
@Test
public void checkSimpleLIAEqualityUnsat() {
Term one = solver.mkInteger(1);
Term assertion = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.ADD, one, one), one);
solver.assertFormula(assertion);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
}
@Test
public void checkSimpleLIASat() {
// x + y = 4 AND x * y = 4
Term four = solver.mkInteger(4);
Term varX = solver.mkConst(solver.getIntegerSort(), "x");
Term varY = solver.mkConst(solver.getIntegerSort(), "y");
Term assertion1 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.MULT, varX, varY), four);
Term assertion2 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.ADD, varX, varY), four);
solver.assertFormula(assertion1);
solver.assertFormula(assertion2);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
assertThat(getInt(varX) + getInt(varY)).isEqualTo(4);
assertThat(getInt(varX) * getInt(varY)).isEqualTo(4);
}
/** Helper to get to int values faster. */
private int getInt(Term cvc5Term) {
String string = solver.getValue(cvc5Term).toString();
return Integer.parseInt(string);
}
@Test
public void checkSimpleLIAUnsat() {
// x + y = 1 AND x * y = 1
Term one = solver.mkInteger(1);
Term varX = solver.mkConst(solver.getIntegerSort(), "x");
Term varY = solver.mkConst(solver.getIntegerSort(), "y");
Term assertion1 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.MULT, varX, varY), one);
Term assertion2 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.ADD, varX, varY), one);
solver.assertFormula(assertion1);
solver.assertFormula(assertion2);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
}
@Test
public void checkLIAModel() {
// 1 + 2 = var
// it follows that var = 3
Term one = solver.mkInteger(1);
Term two = solver.mkInteger(2);
Term var = solver.mkConst(solver.getIntegerSort());
Term assertion = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.ADD, one, two), var);
solver.assertFormula(assertion);
Result result = solver.checkSat();
assertThat(result.isSat()).isTrue();
Term assertionValue = solver.getValue(assertion);
assertThat(assertionValue.toString()).isEqualTo("true");
assertThat(solver.getValue(var).toString()).isEqualTo("3");
}
@Test
public void checkSimpleLIRAUnsat2() {
// x + y = 4 AND x * y = 4
Term threeHalf = solver.mkReal(3, 2);
Term varX = solver.mkConst(solver.getRealSort(), "x");
Term varY = solver.mkConst(solver.getRealSort(), "y");
Term assertion1 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.MULT, varX, varY), threeHalf);
Term assertion2 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.ADD, varX, varY), threeHalf);
solver.assertFormula(assertion1);
solver.assertFormula(assertion2);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
}
@Test
public void checkSimpleLIRASat() {
// x + y = 8/5 AND x > 0 AND y > 0 AND x < 8/5 AND y < 8/5
Term zero = solver.mkReal(0);
Term eightFifth = solver.mkReal(8, 5);
Term varX = solver.mkConst(solver.getRealSort(), "x");
Term varY = solver.mkConst(solver.getRealSort(), "y");
Term assertion1 = solver.mkTerm(Kind.GT, varX, zero);
Term assertion2 = solver.mkTerm(Kind.GT, varY, zero);
Term assertion3 = solver.mkTerm(Kind.LT, varX, eightFifth);
Term assertion4 = solver.mkTerm(Kind.LT, varY, eightFifth);
Term assertion5 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.ADD, varX, varY), eightFifth);
solver.assertFormula(assertion1);
solver.assertFormula(assertion2);
solver.assertFormula(assertion3);
solver.assertFormula(assertion4);
solver.assertFormula(assertion5);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
}
/** Real uses the same operators as int (plain plus, mult etc.). */
@Test
public void checkSimpleLRASat() {
// x * y = 8/5 AND x < 4/5
Term fourFifth = solver.mkReal(4, 5);
Term eightFifth = solver.mkReal(8, 5);
Term varX = solver.mkConst(solver.getRealSort(), "x");
Term varY = solver.mkConst(solver.getRealSort(), "y");
Term assertion1 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.MULT, varX, varY), eightFifth);
Term assertion2 = solver.mkTerm(Kind.LT, varX, fourFifth);
solver.assertFormula(assertion1);
solver.assertFormula(assertion2);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
}
/** Exponents may only be natural number constants. */
@Test
public void checkSimplePow() {
// x ^ 2 = 4 AND x ^ 3 = 8
Term two = solver.mkReal(2);
Term three = solver.mkReal(3);
Term four = solver.mkReal(4);
Term eight = solver.mkReal(8);
Term varX = solver.mkConst(solver.getRealSort(), "x");
Term assertion1 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.POW, varX, two), four);
Term assertion2 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.POW, varX, three), eight);
solver.assertFormula(assertion1);
solver.assertFormula(assertion2);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
}
// TODO: schreibe test von fp variable nach real bzw. umgekehrt. ALso fp formel -> real formel
@Test
public void checkSimpleFPSat() throws CVC5ApiException {
// x * y = 1/4
Term rmTerm = solver.mkRoundingMode(RoundingMode.ROUND_NEAREST_TIES_TO_AWAY);
Op mkRealOp = solver.mkOp(Kind.FLOATINGPOINT_TO_FP_FROM_REAL, 8, 24);
Term oneFourth = solver.mkTerm(mkRealOp, rmTerm, solver.mkReal(1, 4));
Term varX = solver.mkConst(solver.mkFloatingPointSort(8, 24), "x");
Term varY = solver.mkConst(solver.mkFloatingPointSort(8, 24), "y");
Term assertion1 =
solver.mkTerm(
Kind.FLOATINGPOINT_EQ,
solver.mkTerm(Kind.FLOATINGPOINT_MULT, rmTerm, varX, varY),
oneFourth);
solver.assertFormula(assertion1);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
}
@Test
public void checkSimpleFPUnsat() throws CVC5ApiException {
// x * y = 1/4 AND x > 0 AND y < 0
Term rmTerm = solver.mkRoundingMode(RoundingMode.ROUND_NEAREST_TIES_TO_AWAY);
Op mkRealOp = solver.mkOp(Kind.FLOATINGPOINT_TO_FP_FROM_REAL, 8, 24);
Term oneFourth = solver.mkTerm(mkRealOp, rmTerm, solver.mkReal(1, 4));
Term zero = solver.mkTerm(mkRealOp, rmTerm, solver.mkReal(0));
Term varX = solver.mkConst(solver.mkFloatingPointSort(8, 24), "x");
Term varY = solver.mkConst(solver.mkFloatingPointSort(8, 24), "y");
Term assertion1 =
solver.mkTerm(
Kind.FLOATINGPOINT_EQ,
solver.mkTerm(Kind.FLOATINGPOINT_MULT, rmTerm, varX, varY),
oneFourth);
Term assertion2 = solver.mkTerm(Kind.FLOATINGPOINT_GT, varX, zero);
Term assertion3 = solver.mkTerm(Kind.FLOATINGPOINT_LT, varY, zero);
solver.assertFormula(assertion1);
solver.assertFormula(assertion2);
solver.assertFormula(assertion3);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
}
@Test
public void checkSimpleLRAUnsat() {
// x + y = x * y AND x - 1 = 0
Term zero = solver.mkInteger(0);
Term one = solver.mkInteger(1);
Term varX = solver.mkConst(solver.getRealSort(), "x");
Term varY = solver.mkConst(solver.getRealSort(), "y");
Term assertion1 =
solver.mkTerm(
Kind.EQUAL, solver.mkTerm(Kind.MULT, varX, varY), solver.mkTerm(Kind.ADD, varX, varY));
Term assertion2 =
solver.mkTerm(
Kind.EQUAL,
solver.mkTerm(Kind.SUB, varX, solver.mkTerm(Kind.TO_REAL, one)),
solver.mkTerm(Kind.TO_REAL, zero));
solver.assertFormula(assertion1);
solver.assertFormula(assertion2);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
}
@Test
public void checkSimpleLRAUnsat2() {
// x + y = 3/2 AND x * y = 3/2
Term threeHalf = solver.mkReal(3, 2);
Term varX = solver.mkConst(solver.getRealSort(), "x");
Term varY = solver.mkConst(solver.getRealSort(), "y");
Term assertion1 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.MULT, varX, varY), threeHalf);
Term assertion2 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.ADD, varX, varY), threeHalf);
solver.assertFormula(assertion1);
solver.assertFormula(assertion2);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
}
@Test
public void checkSimpleIncrementalSolving() throws CVC5ApiException {
// x + y = 3/2 AND x * y = 3/2 (AND x - 1 = 0)
Term zero = solver.mkInteger(0);
Term one = solver.mkInteger(1);
Term threeHalf = solver.mkReal(3, 2);
Term varX = solver.mkConst(solver.getRealSort(), "x");
Term varY = solver.mkConst(solver.getRealSort(), "y");
// this alone is SAT
Term assertion1 =
solver.mkTerm(
Kind.EQUAL, solver.mkTerm(Kind.MULT, varX, varY), solver.mkTerm(Kind.ADD, varX, varY));
// both 2 and 3 make it UNSAT (either one)
Term assertion2 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.ADD, varX, varY), threeHalf);
Term assertion3 =
solver.mkTerm(
Kind.EQUAL,
solver.mkTerm(Kind.SUB, varX, solver.mkTerm(Kind.TO_REAL, one)),
solver.mkTerm(Kind.TO_REAL, zero));
solver.push();
solver.assertFormula(assertion1);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
solver.push();
solver.assertFormula(assertion2);
satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
solver.pop();
satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
solver.push();
solver.assertFormula(assertion3);
satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
solver.pop();
satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
}
/** Note that model and getValue are seperate! */
@Test
public void checkInvalidModelGetValue() {
Term assertion = solver.mkBoolean(false);
solver.assertFormula(assertion);
Result result = solver.checkSat();
assertThat(result.isSat()).isFalse();
Exception e =
assertThrows(
io.github.cvc5.CVC5ApiRecoverableException.class, () -> solver.getValue(assertion));
assertThat(e.toString()).contains(INVALID_GETVALUE_STRING_SAT);
}
/** The getModel() call needs an array of sorts and terms. */
@Test
public void checkGetModelUnsat() {
Term assertion = solver.mkBoolean(false);
solver.assertFormula(assertion);
Sort[] sorts = new Sort[] {solver.getBooleanSort()};
Term[] terms = new Term[] {assertion};
Result result = solver.checkSat();
assertThat(result.isSat()).isFalse();
Exception e =
assertThrows(
io.github.cvc5.CVC5ApiRecoverableException.class, () -> solver.getModel(sorts, terms));
assertThat(e.toString()).contains(INVALID_MODEL_STRING);
}
/**
* The getModel() call needs an array of sorts and terms. This tests invalid sort parameters.
* Sort: The list of uninterpreted sorts that should be printed in the model. Vars: The list of
* free constants that should be printed in the model. A subset of these may be printed based on
* isModelCoreSymbol.
*/
@Test
public void checkGetModelSatInvalidSort() {
Term assertion = solver.mkBoolean(true);
solver.assertFormula(assertion);
Sort[] sorts = new Sort[] {solver.getBooleanSort()};
Term[] terms = new Term[] {assertion};
Result result = solver.checkSat();
assertThat(result.isSat()).isTrue();
Exception e =
assertThrows(
io.github.cvc5.CVC5ApiRecoverableException.class, () -> solver.getModel(sorts, terms));
assertThat(e.toString()).contains("Expecting an uninterpreted sort as argument to getModel.");
}
/** Same as checkGetModelSatInvalidSort but with invalid term. */
@Test
public void checkGetModelSatInvalidTerm() {
Term assertion = solver.mkBoolean(true);
solver.assertFormula(assertion);
Sort[] sorts = new Sort[] {};
Term[] terms = new Term[] {assertion};
Result result = solver.checkSat();
assertThat(result.isSat()).isTrue();
Exception e =
assertThrows(
io.github.cvc5.CVC5ApiRecoverableException.class, () -> solver.getModel(sorts, terms));
assertThat(e.toString()).contains("Expecting a free constant as argument to getModel.");
}
@Test
public void checkGetModelSat() {
Term assertion = solver.mkConst(solver.getBooleanSort());
solver.assertFormula(assertion);
Sort[] sorts = new Sort[] {};
Term[] terms = new Term[] {assertion};
Result result = solver.checkSat();
assertThat(result.isSat()).isTrue();
String model = solver.getModel(sorts, terms);
// The toString of vars (consts) is the internal variable id
assertThat(model).contains("(\n" + "(define-fun " + assertion + " () Bool true)\n" + ")");
}
/**
* The getModel() call needs an array of sorts and terms. This tests what happens if you put empty
* arrays into it.
*/
@Test
public void checkInvalidGetModel() {
Term assertion = solver.mkBoolean(false);
solver.assertFormula(assertion);
Result result = solver.checkSat();
assertThat(result.isSat()).isFalse();
Sort[] sorts = new Sort[1];
Term[] terms = new Term[1];
assertThrows(NullPointerException.class, () -> solver.getModel(sorts, terms));
}
/** It does not matter if you take an int or array or bv here, all result in the same error. */
@Test
public void checkInvalidTypeOperationsAssert() throws CVC5ApiException {
Sort bvSort = solver.mkBitVectorSort(16);
Term bvVar = solver.mkConst(bvSort, "bla");
Term assertion = solver.mkTerm(Kind.BITVECTOR_AND, bvVar, bvVar);
Exception e =
assertThrows(io.github.cvc5.CVC5ApiException.class, () -> solver.assertFormula(assertion));
assertThat(e.toString()).contains("Expected term with sort Bool");
}
/** It does not matter if you take an int or array or bv here, all result in the same error. */
@Test
public void checkInvalidTypeOperationsCheckSat() throws CVC5ApiException {
Sort bvSort = solver.mkBitVectorSort(16);
Term bvVar = solver.mkConst(bvSort);
Term intVar = solver.mkConst(solver.getIntegerSort());
Term arrayVar =
solver.mkConst(solver.mkArraySort(solver.getIntegerSort(), solver.getIntegerSort()));
Exception e =
assertThrows(
io.github.cvc5.CVC5ApiException.class, () -> solver.mkTerm(Kind.AND, bvVar, bvVar));
assertThat(e.toString()).contains("expecting a Boolean subexpression");
e =
assertThrows(
io.github.cvc5.CVC5ApiException.class, () -> solver.mkTerm(Kind.AND, intVar, intVar));
assertThat(e.toString()).contains("expecting a Boolean subexpression");
e =
assertThrows(
io.github.cvc5.CVC5ApiException.class,
() -> solver.mkTerm(Kind.AND, arrayVar, arrayVar));
assertThat(e.toString()).contains("expecting a Boolean subexpression");
}
@Test
public void checkBvInvalidZeroWidthAssertion() {
Exception e =
assertThrows(io.github.cvc5.CVC5ApiException.class, () -> solver.mkBitVector(0, 1));
assertThat(e.toString()).contains("Invalid argument '0' for 'size', expected a bit-width > 0");
}
@Test
public void checkBvInvalidNegativeWidthCheckAssertion() {
Exception e =
assertThrows(io.github.cvc5.CVC5ApiException.class, () -> solver.mkBitVector(-1, 1));
assertThat(e.toString()).contains("Expected size '-1' to be non negative.");
}
@Test
public void checkSimpleBvEqualitySat() throws CVC5ApiException {
// 1 + 0 = 1 with bitvectors
Term bvOne = solver.mkBitVector(16, 1);
Term bvZero = solver.mkBitVector(16, 0);
Term assertion =
solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.BITVECTOR_ADD, bvZero, bvOne), bvOne);
solver.assertFormula(assertion);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
}
@Test
public void checkSimpleBvEqualityUnsat() throws CVC5ApiException {
// 0 + 1 = 2 UNSAT with bitvectors
Term bvZero = solver.mkBitVector(16, 0);
Term bvOne = solver.mkBitVector(16, 1);
Term bvTwo = solver.mkBitVector(16, 2);
Term assertion =
solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.BITVECTOR_ADD, bvZero, bvOne), bvTwo);
solver.assertFormula(assertion);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
}
@Test
public void checkSimpleBvUnsat() throws CVC5ApiException {
// var + 1 = 0 & var < max bitvector & var > 0; both < and > signed
// Because of bitvector nature its UNSAT now
Term bvVar = solver.mkConst(solver.mkBitVectorSort(16), "bvVar");
Term bvOne = solver.mkBitVector(16, 1);
Term bvZero = solver.mkBitVector(16, 0);
Term assertion1 =
solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.BITVECTOR_ADD, bvVar, bvOne), bvZero);
// mkMaxSigned(16);
Term assertion2 = solver.mkTerm(Kind.BITVECTOR_SLT, bvVar, makeMaxCVC5Bitvector(16, true));
Term assertion3 = solver.mkTerm(Kind.BITVECTOR_SGT, bvVar, bvZero);
solver.assertFormula(assertion1);
solver.assertFormula(assertion2);
solver.assertFormula(assertion3);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
}
@Ignore
public void checkBvDistinct() throws CVC5ApiException {
Sort bvSort = solver.mkBitVectorSort(6);
List<Term> bvs = new ArrayList<>();
for (int i = 0; i < 64; i++) {
bvs.add(solver.mkConst(bvSort, "a" + i + "_"));
}
// TODO: this got worse in the 1.0.0 release and now this runs endlessly as well, check in later
// version again.
Term distinct2 = solver.mkTerm(Kind.DISTINCT, bvs.toArray(new Term[0]));
solver.assertFormula(distinct2);
assertThat(solver.checkSat().isSat()).isTrue();
solver.resetAssertions();
// TODO: The following runs endlessly; recheck for new versions!
/*
bvs.add(solver.mkConst(bvSort, "b" + "_"));
Term distinct3 = solver.mkTerm(Kind.DISTINCT, bvs.toArray(new Term[0]));
solver.assertFormula(distinct3);
assertThat(solver.checkSat().isSat()).isFalse();
*/
}
/*
* CVC5 fails some easy quantifier tests.
*/
@Test
public void checkQuantifierExistsIncomplete() {
// (not exists x . not b[x] = 0) AND (b[123] = 0) is SAT
setupArrayQuant();
Term zero = solver.mkInteger(0);
Term xBound = solver.mkVar(solver.getIntegerSort(), "x");
Term quantifiedVars = solver.mkTerm(Kind.VARIABLE_LIST, xBound);
Term aAtxEq0s = aAtxEq0.substitute(x, xBound);
Term exists = solver.mkTerm(Kind.EXISTS, quantifiedVars, solver.mkTerm(Kind.NOT, aAtxEq0s));
Term notExists = solver.mkTerm(Kind.NOT, exists);
Term select123 = solver.mkTerm(Kind.SELECT, array, solver.mkInteger(123));
Term selectEq0 = solver.mkTerm(Kind.EQUAL, select123, zero);
Term assertion = solver.mkTerm(Kind.AND, notExists, selectEq0);
// CVC5 does not allow non quantifier formulas as the top most formula
Exception e =
assertThrows(io.github.cvc5.CVC5ApiException.class, () -> solver.assertFormula(assertion));
assertThat(e.getMessage().strip()).matches(INVALID_TERM_BOUND_VAR);
}
@Test
public void checkQuantifierEliminationLIA() {
// build formula: (forall x . ((x < 5) | (7 < x + y)))
// quantifier-free equivalent: (2 < y) or (>= y 3)
setupArrayQuant();
Term three = solver.mkInteger(3);
Term five = solver.mkInteger(5);
Term seven = solver.mkInteger(7);
Term y = solver.mkConst(solver.getIntegerSort(), "y");
Term first = solver.mkTerm(Kind.LT, x, five);
Term second = solver.mkTerm(Kind.LT, seven, solver.mkTerm(Kind.ADD, x, y));
Term body = solver.mkTerm(Kind.OR, first, second);
Term xBound = solver.mkVar(solver.getIntegerSort(), "xBound");
Term quantifiedVars = solver.mkTerm(Kind.VARIABLE_LIST, xBound);
Term bodySubst = body.substitute(x, xBound);
Term assertion = solver.mkTerm(Kind.FORALL, quantifiedVars, bodySubst);
Term result = solver.getQuantifierElimination(assertion);
Term resultCheck = solver.mkTerm(Kind.GEQ, y, three);
assertThat(result.toString()).isEqualTo(resultCheck.toString());
}
@Test
public void checkQuantifierAndModelWithUf() throws CVC5ApiException {
Term var = solver.mkConst(solver.getIntegerSort(), "var");
// start with a normal, free variable!
Term boundVar = solver.mkConst(solver.getIntegerSort(), "boundVar");
Term varIsOne = solver.mkTerm(Kind.EQUAL, var, solver.mkInteger(4));
// try not to use 0 as this is the default value for CVC5 models
Term boundVarIsTwo = solver.mkTerm(Kind.EQUAL, boundVar, solver.mkInteger(2));
Term boundVarIsThree = solver.mkTerm(Kind.EQUAL, boundVar, solver.mkInteger(3));
String func = "func";
Sort intSort = solver.getIntegerSort();
Sort ufSort = solver.mkFunctionSort(intSort, intSort);
Term uf = solver.mkConst(ufSort, func);
Term funcAtBoundVar = solver.mkTerm(Kind.APPLY_UF, uf, boundVar);
Term body =
solver.mkTerm(Kind.AND, boundVarIsTwo, solver.mkTerm(Kind.EQUAL, var, funcAtBoundVar));
// This is the bound variable used for boundVar
Term boundVarBound = solver.mkVar(solver.getIntegerSort(), "boundVar");
Term quantifiedVars = solver.mkTerm(Kind.VARIABLE_LIST, boundVarBound);
// Subst all boundVar variables with the bound version
Term bodySubst = body.substitute(boundVar, boundVarBound);
Term quantFormula = solver.mkTerm(Kind.EXISTS, quantifiedVars, bodySubst);
// var = 4 & boundVar = 3 & exists boundVar . ( boundVar = 2 & f(boundVar) = var )
Term overallFormula = solver.mkTerm(Kind.AND, varIsOne, boundVarIsThree, quantFormula);
solver.assertFormula(overallFormula);
Result satCheck = solver.checkSat();
// SAT
assertThat(satCheck.isSat()).isTrue();
// check Model
// var = 4 & boundVar = 3 & exists boundVar . ( boundVar = 2 & f(2) = 4 )
// It seems like CVC5 can't return quantified variables,
// therefore we can't get a value for the uf!
assertThat(solver.getValue(var).toString()).isEqualTo("4");
assertThat(solver.getValue(boundVar).toString()).isEqualTo("3");
// funcAtBoundVar and body do not have boundVars in them!
assertThat(solver.getValue(funcAtBoundVar).toString()).isEqualTo("4");
assertThat(solver.getValue(body).toString()).isEqualTo("false");
// The function is a applied uf
assertThat(funcAtBoundVar.getKind()).isEqualTo(Kind.APPLY_UF);
assertThat(funcAtBoundVar.getSort()).isEqualTo(solver.getIntegerSort());
assertThat(funcAtBoundVar.hasSymbol()).isFalse();
assertThat(solver.getValue(funcAtBoundVar).toString()).isEqualTo("4");
// The function has 2 children, 1st is the function, 2nd is the argument
assertThat(funcAtBoundVar.getNumChildren()).isEqualTo(2);
assertThat(funcAtBoundVar.toString()).isEqualTo("(func boundVar)");
assertThat(funcAtBoundVar.getChild(0).toString()).isEqualTo("func");
assertThat(funcAtBoundVar.getChild(1).toString()).isEqualTo("boundVar");
// Now the same function within the body with the bound var substituted
// A quantifier has 2 children, the second is the body
assertThat(quantFormula.getNumChildren()).isEqualTo(2);
// The body is the AND formula from above, the right child is var = func
// The right child of var = func is the func
Term funcModel = quantFormula.getChild(1).getChild(1).getChild(1);
// This too is a applied uf
assertThat(funcModel.getKind()).isEqualTo(Kind.APPLY_UF);
// This should have the same SMTLIB2 string as the declaration
assertThat(funcModel.toString()).isEqualTo(funcAtBoundVar.toString());
// But the argument should be a bound var
// You can not get a value for the entire function Term as it contains a bound var! (see below)
assertThat(funcModel.getNumChildren()).isEqualTo(2);
assertThat(funcModel.getChild(0).hasSymbol()).isTrue();
assertThat(funcModel.getChild(0).getSymbol()).isEqualTo("func");
// For some reason the function in an UF is CONSTANT type after a SAT call but if you try to get
// the value it changes and is no longer the same as before, but a
// LAMBDA Kind with the argument (in some internal string representation + its type) and the
// result. You can get the result as the second child (child 1)
assertThat(funcModel.getChild(0).getKind()).isEqualTo(Kind.CONSTANT);
// Without getValue the Kind and num of children is fine
assertThat(funcModel.getChild(0).getNumChildren()).isEqualTo(0);
// The Sort is the function sort (which is the lambda)
assertThat(funcModel.getChild(0).getSort()).isEqualTo(funcAtBoundVar.getChild(0).getSort());
assertThat(solver.getValue(funcModel.getChild(0)).getNumChildren()).isEqualTo(2);
assertThat(solver.getValue(funcModel.getChild(0)).getKind()).isEqualTo(Kind.LAMBDA);
assertThat(solver.getValue(funcModel.getChild(0)).toString())
.isEqualTo("(lambda ((_arg_1 Int)) 4)");
assertThat(solver.getValue(funcModel.getChild(0)).getChild(1).toString()).isEqualTo("4");
// The function parameter is fine
assertThat(funcModel.getChild(1).toString()).isEqualTo("boundVar");
// Now it is a VARIABLE (bound variables in CVC5)
assertThat(funcModel.getChild(1).getKind()).isEqualTo(Kind.VARIABLE);
// CVC5 does not allow the usage of getValue() on bound vars!
Exception e =
assertThrows(io.github.cvc5.CVC5ApiException.class, () -> solver.getValue(boundVarBound));
assertThat(e.getMessage().strip()).matches(INVALID_TERM_BOUND_VAR);
e = assertThrows(io.github.cvc5.CVC5ApiException.class, () -> solver.getValue(bodySubst));
assertThat(e.getMessage().strip()).matches(INVALID_TERM_BOUND_VAR);
}
/** CVC5 does not support Array quantifier elimination. This would run endlessly! */
@Ignore
@Test
public void checkArrayQuantElim() {
setupArrayQuant();
Term body = solver.mkTerm(Kind.OR, aAtxEq0, aAtxEq1);
Term xBound = solver.mkVar(solver.getIntegerSort(), "x_b");
Term quantifiedVars = solver.mkTerm(Kind.VARIABLE_LIST, xBound);
Term bodySubst = body.substitute(x, xBound);
Term assertion = solver.mkTerm(Kind.FORALL, quantifiedVars, bodySubst);
Term result = solver.getQuantifierElimination(assertion);
String resultString =
"(forall ((x_b Int)) (let ((_let_0 (select a x_b))) (or (= _let_0 0) (= _let_0 1))) )";
assertThat(result.toString()).isEqualTo(resultString);
}
/** CVC5 does support Bv quantifier elim.! */
@Test
public void checkQuantifierEliminationBV() throws CVC5ApiException {
// build formula: exists y : bv[2]. x * y = 1
// quantifier-free equivalent: x = 1 | x = 3
// or extract_0_0 x = 1
// Note from CVC5: a witness expression; first parameter is a BOUND_VAR_LIST, second is the
// witness body"
int width = 2;
Term xBv = solver.mkConst(solver.mkBitVectorSort(width), "x_bv");
Term yBv = solver.mkConst(solver.mkBitVectorSort(width), "y_bv");
Term mult = solver.mkTerm(Kind.BITVECTOR_MULT, xBv, yBv);
Term body = solver.mkTerm(Kind.EQUAL, mult, solver.mkBitVector(2, 1));
Term xBound = solver.mkVar(solver.mkBitVectorSort(width), "y_bv");
Term quantifiedVars = solver.mkTerm(Kind.VARIABLE_LIST, xBound);
Term bodySubst = body.substitute(yBv, xBound);
Term assertion = solver.mkTerm(Kind.EXISTS, quantifiedVars, bodySubst);
Term quantElim = solver.getQuantifierElimination(assertion);
assertThat(quantElim.toString())
.isEqualTo(
"(= (bvmul x_bv (witness ((x0 (_ BitVec 2))) (or (= (bvmul x_bv x0) #b01) (not (="
+ " (concat #b0 ((_ extract 0 0) (bvor x_bv (bvneg x_bv)))) #b01))))) #b01)");
// TODO: formely you could get a better result Term by using getValue(). But now getValue() only
// works after SAT since 1.0.0 and then getValue() prints trivial statements like false.
}
@Test
public void checkArraySat() {
// ((x = 123) & (select(arr, 5) = 123)) => ((select(arr, 5) = x) & (x = 123))
Term five = solver.mkInteger(5);
Term oneTwoThree = solver.mkInteger(123);
Term xInt = solver.mkConst(solver.getIntegerSort(), "x_int");
Sort arraySort = solver.mkArraySort(solver.getIntegerSort(), solver.getIntegerSort());
Term arr = solver.mkConst(arraySort, "arr");
Term xEq123 = solver.mkTerm(Kind.EQUAL, xInt, oneTwoThree);
Term selAat5Eq123 =
solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.SELECT, arr, five), oneTwoThree);
Term selAat5EqX = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.SELECT, arr, five), xInt);
Term leftAnd = solver.mkTerm(Kind.AND, xEq123, selAat5Eq123);
Term rightAnd = solver.mkTerm(Kind.AND, xEq123, selAat5EqX);
Term impl = solver.mkTerm(Kind.IMPLIES, leftAnd, rightAnd);
solver.assertFormula(impl);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
}
@Test
public void checkArrayUnsat() {
// (x = 123) & (select(arr, 5) = 123) & (select(arr, 5) != x)
Term five = solver.mkInteger(5);
Term oneTwoThree = solver.mkInteger(123);
Term xInt = solver.mkConst(solver.getIntegerSort(), "x_int");
Sort arraySort = solver.mkArraySort(solver.getIntegerSort(), solver.getIntegerSort());
Term arr = solver.mkConst(arraySort, "arr");
Term xEq123 = solver.mkTerm(Kind.EQUAL, xInt, oneTwoThree);
Term selAat5Eq123 =
solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.SELECT, arr, five), oneTwoThree);
Term selAat5NotEqX =
solver.mkTerm(
Kind.NOT, solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.SELECT, arr, five), xInt));
Term assertion = solver.mkTerm(Kind.AND, xEq123, selAat5Eq123, selAat5NotEqX);
solver.assertFormula(assertion);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
}
@Test
public void checkUnsatCore() {
solver.setOption("produce-unsat-cores", "true");
solver.setOption("produce-proofs", "true");
// (a & b) & (not(a OR b))
// Enable UNSAT Core first!
solver.setOption("produce-unsat-cores", "true");
Sort boolSort = solver.getBooleanSort();
Term a = solver.mkConst(boolSort, "a");
Term b = solver.mkConst(boolSort, "b");
Term aAndb = solver.mkTerm(Kind.AND, a, b);
Term notaOrb = solver.mkTerm(Kind.NOT, solver.mkTerm(Kind.OR, a, b));
solver.assertFormula(aAndb);
solver.assertFormula(notaOrb);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
Term[] unsatCore = solver.getUnsatCore();
// UnsatCores are iterable
for (Term e : unsatCore) {
assertThat(e.toString()).isIn(Arrays.asList("(not (or a b))", "(and a b)"));
}
}
@Test
public void checkCustomTypesAndUFs() {
// 0 <= f(x)
// 0 <= f(y)
// f(x) + f(y) <= 1
// not p(0)
// p(f(y))
Term zero = solver.mkInteger(0);
Term one = solver.mkInteger(1);
Sort boolSort = solver.getBooleanSort();
Sort intSort = solver.getIntegerSort();
// You may use custom sorts just like bool or int
Sort mySort = solver.mkParamSort("f");
// Sort for UFs later
Sort mySortToInt = solver.mkFunctionSort(mySort, intSort);
Sort intToBool = solver.mkFunctionSort(intSort, boolSort);
Term xTyped = solver.mkConst(mySort, "x");
Term yTyped = solver.mkConst(mySort, "y");
// declare UFs
Term f = solver.mkConst(mySortToInt, "f");
Term p = solver.mkConst(intToBool, "p");
// Apply UFs
Term fx = solver.mkTerm(Kind.APPLY_UF, f, xTyped);
Term fy = solver.mkTerm(Kind.APPLY_UF, f, yTyped);
Term sum = solver.mkTerm(Kind.ADD, fx, fy);
Term p0 = solver.mkTerm(Kind.APPLY_UF, p, zero);
Term pfy = solver.mkTerm(Kind.APPLY_UF, p, fy);
// Make some assumptions
Term assumptions1 =
solver.mkTerm(
Kind.AND,
solver.mkTerm(Kind.LEQ, zero, fx),
solver.mkTerm(Kind.LEQ, zero, fy),
solver.mkTerm(Kind.LEQ, sum, one));
Term assumptions2 = solver.mkTerm(Kind.AND, p0.notTerm(), pfy);
solver.assertFormula(assumptions1);
solver.assertFormula(assumptions2);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
}
@Test
public void checkBooleanUFDeclaration() {
Sort boolSort = solver.getBooleanSort();
Sort intSort = solver.getIntegerSort();
// arg is bool, return is int
Sort ufSort = solver.mkFunctionSort(boolSort, intSort);
Term uf = solver.mkConst(ufSort, "fun_bi");
Term ufTrue = solver.mkTerm(Kind.APPLY_UF, uf, solver.mkTrue());
Term ufFalse = solver.mkTerm(Kind.APPLY_UF, uf, solver.mkFalse());
Term assumptions = solver.mkTerm(Kind.NOT, solver.mkTerm(Kind.EQUAL, ufTrue, ufFalse));
solver.assertFormula(assumptions);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
}
@Test
public void checkLIAUfsUnsat() {
// 0 <= f(x)
// 0 <= f(y)
// f(x) + f(y) = x
// f(x) + f(y) = y
// f(x) = x + 1
// f(y) = y - 1
Term zero = solver.mkInteger(0);
Term one = solver.mkInteger(1);
Sort intSort = solver.getIntegerSort();
// Sort for UFs later
Sort intToInt = solver.mkFunctionSort(intSort, intSort);
Term xInt = solver.mkConst(intSort, "x");
Term yInt = solver.mkConst(intSort, "y");
// declare UFs
Term f = solver.mkConst(intToInt, "f");
// Apply UFs
Term fx = solver.mkTerm(Kind.APPLY_UF, f, xInt);
Term fy = solver.mkTerm(Kind.APPLY_UF, f, yInt);
Term plus = solver.mkTerm(Kind.ADD, fx, fy);
// Make some assumptions
Term assumptions1 =
solver.mkTerm(
Kind.AND,
solver.mkTerm(Kind.LEQ, zero, fx),
solver.mkTerm(Kind.EQUAL, plus, xInt),
solver.mkTerm(Kind.LEQ, zero, fy));
Term assumptions2 =
solver.mkTerm(
Kind.AND,
solver.mkTerm(Kind.EQUAL, fx, solver.mkTerm(Kind.ADD, xInt, one)),
solver.mkTerm(Kind.EQUAL, fy, solver.mkTerm(Kind.SUB, yInt, one)),
solver.mkTerm(Kind.EQUAL, plus, yInt));
solver.assertFormula(assumptions1);
solver.assertFormula(assumptions2);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isFalse();
}
@Test
public void checkLIAUfsSat() {
// f(x) = x + 1
// f(y) = y - 1
// x = y -> f(x) + f(y) = x AND f(x) + f(y) = y
Term one = solver.mkInteger(1);
Sort intSort = solver.getIntegerSort();
// Sort for UFs later
Sort intToInt = solver.mkFunctionSort(intSort, intSort);
Term xInt = solver.mkConst(intSort, "x");
Term yInt = solver.mkConst(intSort, "y");
// declare UFs
Term f = solver.mkConst(intToInt, "f");
// Apply UFs
Term fx = solver.mkTerm(Kind.APPLY_UF, f, xInt);
Term fy = solver.mkTerm(Kind.APPLY_UF, f, yInt);
Term plus = solver.mkTerm(Kind.ADD, fx, fy);
Term plusEqx = solver.mkTerm(Kind.EQUAL, plus, xInt);
Term plusEqy = solver.mkTerm(Kind.EQUAL, plus, yInt);
Term xEqy = solver.mkTerm(Kind.EQUAL, yInt, xInt);
Term xEqyImplplusEqxAndy =
solver.mkTerm(Kind.IMPLIES, xEqy, solver.mkTerm(Kind.AND, plusEqx, plusEqy));
Term assumptions =
solver.mkTerm(
Kind.AND,
solver.mkTerm(Kind.EQUAL, fx, solver.mkTerm(Kind.ADD, xInt, one)),
solver.mkTerm(Kind.EQUAL, fy, solver.mkTerm(Kind.SUB, yInt, one)),
xEqyImplplusEqxAndy);
solver.assertFormula(assumptions);
Result satCheck = solver.checkSat();
assertThat(satCheck.isSat()).isTrue();
assertThat(solver.getValue(fx).toString()).isEqualTo("0");
}
@Test
public void checkStringCompare() {
Term var1 = solver.mkConst(solver.getStringSort(), "0");
Term var2 = solver.mkConst(solver.getStringSort(), "1");
Term f =
solver
.mkTerm(Kind.STRING_LEQ, var1, var2)
.andTerm(solver.mkTerm(Kind.STRING_LEQ, var2, var1));
// Thats no problem
solver.assertFormula(f);
assertThat(solver.checkSat().isSat()).isTrue();
// implying that 1 <= 2 & 2 <= 1 -> 1 = 2 however runs indefinitely
/*
Term implication = f.notTerm().orTerm(solver.mkTerm(Kind.EQUAL, var2, var1));
solver.assertFormula(implication.notTerm());
assertThat(solver.checkSat().isUnsat()).isTrue();
*/
}
/** Sets up array and quantifier based formulas for tests. */
private void setupArrayQuant() {
Term zero = solver.mkInteger(0);
Term one = solver.mkInteger(1);
x = solver.mkVar(solver.getIntegerSort(), "x");
Sort arraySort = solver.mkArraySort(solver.getIntegerSort(), solver.getIntegerSort());
array = solver.mkVar(arraySort, "a");
aAtxEq0 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.SELECT, array, x), zero);
aAtxEq1 = solver.mkTerm(Kind.EQUAL, solver.mkTerm(Kind.SELECT, array, x), one);
}
/**
* For some reason CVC5 does not provide API to create max (or min) size signed/unsigned
* bitvectors.
*
* @param width of the bitvector term.
* @param signed true if signed. false for unsigned.
* @return Max size bitvector term.
*/
private Term makeMaxCVC5Bitvector(int width, boolean signed) throws CVC5ApiException {
String bitvecString;
if (signed) {
bitvecString = String.valueOf(new char[width - 1]).replace("\0", "1");
bitvecString = "0" + bitvecString;
} else {
bitvecString = String.valueOf(new char[width]).replace("\0", "1");
}
return solver.mkBitVector(width, bitvecString, 2);
}
@Test
public void termAccessAfterModelClosed() throws CVC5ApiException {
Solver secondSolver = createEnvironment();
Term v = solver.mkConst(solver.getIntegerSort(), "v");
Term one = solver.mkInteger(1);
Term eq = solver.mkTerm(Kind.EQUAL, v, one); // v==1
secondSolver.assertFormula(eq);
Result result = secondSolver.checkSat();
assertThat(result.isSat()).isTrue();
Term valueV = secondSolver.getValue(v);
Preconditions.checkNotNull(valueV);
System.out.println(valueV);
}
}
| 48,688 | 38.392395 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5NumeralFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import static io.github.cvc5.Kind.ADD;
import static io.github.cvc5.Kind.DIVISION;
import static io.github.cvc5.Kind.INTS_DIVISION;
import static io.github.cvc5.Kind.INTS_MODULUS;
import static io.github.cvc5.Kind.MULT;
import static io.github.cvc5.Kind.SUB;
import com.google.common.collect.ImmutableSet;
import io.github.cvc5.CVC5ApiException;
import io.github.cvc5.Kind;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import java.math.BigInteger;
import java.util.List;
import java.util.regex.Pattern;
import org.sosy_lab.java_smt.api.NumeralFormula;
import org.sosy_lab.java_smt.basicimpl.AbstractNumeralFormulaManager;
@SuppressWarnings("ClassTypeParameterName")
abstract class CVC5NumeralFormulaManager<
ParamFormulaType extends NumeralFormula, ResultFormulaType extends NumeralFormula>
extends AbstractNumeralFormulaManager<
Term, Sort, Solver, ParamFormulaType, ResultFormulaType, Term> {
/**
* CVC4 fails hard when creating Integers/Rationals instead of throwing an exception for invalid
* number format. Thus lets check the format.
*/
public static final Pattern INTEGER_NUMBER = Pattern.compile("(-)?(\\d)+");
public static final Pattern RATIONAL_NUMBER = Pattern.compile("(-)?(\\d)+(.)?(\\d)*");
/**
* Operators for arithmetic functions that return a numeric value. Remove if not needed after
* tests!
*/
@SuppressWarnings("unused")
private static final ImmutableSet<Kind> NUMERIC_FUNCTIONS =
ImmutableSet.of(ADD, SUB, MULT, DIVISION, INTS_DIVISION, INTS_MODULUS);
protected final Solver solver;
CVC5NumeralFormulaManager(CVC5FormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
solver = pCreator.getEnv();
}
protected abstract Sort getNumeralType();
@Override
protected boolean isNumeral(Term pVal) {
// There seems to be no way of checking if a Term is const in CVC5
return pVal.isIntegerValue() || pVal.isRealValue();
}
/**
* Check whether the current term is numeric and the value of a term is determined by only
* numerals, i.e. no variable is contained. This method should check as precisely as possible the
* situations in which CVC5 supports arithmetic operations like multiplications.
*
* <p>Example: TRUE for "1", "2+3", "ite(x,2,3) and FALSE for "x", "x+2", "ite(1=2,x,0)"
*/
/* Enable if needed!
boolean consistsOfNumerals(Term val) {
Set<Term> finished = new HashSet<>();
Deque<Term> waitlist = new ArrayDeque<>();
waitlist.add(val);
while (!waitlist.isEmpty()) {
Term e = waitlist.pop();
if (!finished.add(e)) {
continue;
}
if (isNumeral(e)) {
// true, skip and check others
} else if (NUMERIC_FUNCTIONS.contains(e.getKind())) {
Iterables.addAll(waitlist, e);
} else if (ITE.equals(e.getKind())) {
// ignore condition, just use the if- and then-case
waitlist.add(e.getChild(1));
waitlist.add(e.getChild(2));
} else {
return false;
}
}
return true;
}
*/
@Override
protected Term makeNumberImpl(long i) {
// we connot use "new Rational(long)", because it uses "unsigned long".
return makeNumberImpl(Long.toString(i));
}
@Override
protected Term makeNumberImpl(BigInteger pI) {
return makeNumberImpl(pI.toString());
}
@Override
protected Term makeNumberImpl(String pI) {
if (!RATIONAL_NUMBER.matcher(pI).matches()) {
throw new NumberFormatException("number is not an rational value: " + pI);
}
try {
return solver.mkReal(pI);
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"You tried creating a invalid rational number with input Sring: " + pI + ".", e);
}
}
@Override
protected Term makeVariableImpl(String varName) {
Sort type = getNumeralType();
return getFormulaCreator().makeVariable(type, varName);
}
@Override
protected Term multiply(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.MULT, pParam1, pParam2);
/*
* In CVC4 we had to check if the terms consist of only numerals, if this
* fails we have to do it again!
if (consistsOfNumerals(pParam1) || consistsOfNumerals(pParam2)) {
return solver.mkTerm(Kind.MULT, pParam1, pParam2);
} else {
return super.multiply(pParam1, pParam2);
}
*/
}
@Override
protected Term modulo(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.INTS_MODULUS, pParam1, pParam2);
}
@Override
protected Term negate(Term pParam1) {
return solver.mkTerm(Kind.NEG, pParam1);
}
@Override
protected Term add(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.ADD, pParam1, pParam2);
}
@Override
protected Term subtract(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.SUB, pParam1, pParam2);
}
@Override
protected Term equal(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.EQUAL, pParam1, pParam2);
}
@Override
protected Term greaterThan(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.GT, pParam1, pParam2);
}
@Override
protected Term greaterOrEquals(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.GEQ, pParam1, pParam2);
}
@Override
protected Term lessThan(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.LT, pParam1, pParam2);
}
@Override
protected Term lessOrEquals(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.LEQ, pParam1, pParam2);
}
@Override
protected Term distinctImpl(List<Term> pParam) {
return solver.mkTerm(Kind.DISTINCT, pParam.toArray(new Term[0]));
}
}
| 5,998 | 29.92268 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5QuantifiedFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import io.github.cvc5.Kind;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import java.util.ArrayList;
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 CVC5QuantifiedFormulaManager
extends AbstractQuantifiedFormulaManager<Term, Sort, Solver, Term> {
private final Solver solver;
protected CVC5QuantifiedFormulaManager(FormulaCreator<Term, Sort, Solver, Term> pFormulaCreator) {
super(pFormulaCreator);
solver = pFormulaCreator.getEnv();
}
/*
* (non-Javadoc) CVC4s quantifier support is dependent on the options used.
* Without any options it tends to run infinitely on many theories or examples.
* There are 2 options improving this: full-saturate-quant and sygus-inst.
* full-saturate-quant is activated in JavaSMT per default.
* You can try combinations of them, or just one if a query is not solveable.
* More info on full-saturate-quant: Enables "enumerative instantiation",
* see: https://homepage.divms.uiowa.edu/~ajreynol/tacas18.pdf
* More info on sygus-inst: Enables syntax-guided instantiation,
* see https://homepage.divms.uiowa.edu/~ajreynol/tacas21.pdf
* This approach tends to work well when the quantified formula involves
* theories (e.g. strings) where more traditional quantifier instantiation
* heuristics do not apply.
* This applies to CVC4 and CVC5!
*/
@Override
protected Term eliminateQuantifiers(Term input) throws SolverException, InterruptedException {
try {
return solver.getQuantifierElimination(input);
} catch (RuntimeException e) {
// quantifier elimination failed, simply return the input
return input;
}
}
/*
* Makes the quantifier entered in CVC4/CVC5. Note that CVC4/CVC5 uses bound variables in
* quantified formulas instead of the normal free vars. We create a bound copy for every var
* and substitute the free var for the bound var in the body Formula. Note that CVC4/CVC5 uses
* their internal Lists for the variable list in quantifiers.
*/
@Override
public Term mkQuantifier(Quantifier pQ, List<Term> pVars, Term pBody) {
if (pVars.isEmpty()) {
throw new IllegalArgumentException("Empty variable list for quantifier.");
} else {
List<Term> boundVars = new ArrayList<>();
Term substBody = pBody;
// every free needs a bound copy. As the internal Id is different for every variable, even
// with the same name, this is fine.
for (Term var : pVars) {
Term boundCopy = ((CVC5FormulaCreator) formulaCreator).makeBoundCopy(var);
boundVars.add(boundCopy);
substBody = substBody.substitute(var, boundCopy);
}
Kind quant = pQ == Quantifier.EXISTS ? Kind.EXISTS : Kind.FORALL;
Term boundVarsList = solver.mkTerm(Kind.VARIABLE_LIST, boundVars.toArray(new Term[0]));
return solver.mkTerm(quant, boundVarsList, substBody);
}
}
}
| 3,371 | 39.142857 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5RationalFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import io.github.cvc5.Kind;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import java.math.BigDecimal;
import org.sosy_lab.java_smt.api.NumeralFormula;
import org.sosy_lab.java_smt.api.NumeralFormula.RationalFormula;
import org.sosy_lab.java_smt.api.RationalFormulaManager;
public class CVC5RationalFormulaManager
extends CVC5NumeralFormulaManager<NumeralFormula, RationalFormula>
implements RationalFormulaManager {
CVC5RationalFormulaManager(
CVC5FormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
}
@Override
protected Sort getNumeralType() {
return getFormulaCreator().getRationalType();
}
@Override
protected Term makeNumberImpl(double pNumber) {
return makeNumberImpl(Double.toString(pNumber));
}
@Override
protected Term makeNumberImpl(BigDecimal pNumber) {
return makeNumberImpl(pNumber.toPlainString());
}
@Override
public Term divide(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.DIVISION, pParam1, pParam2);
}
@Override
protected Term floor(Term pNumber) {
return solver.mkTerm(Kind.TO_INTEGER, pNumber);
}
}
| 1,461 | 26.584906 | 78 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5SLFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import io.github.cvc5.Kind;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import org.sosy_lab.java_smt.basicimpl.AbstractSLFormulaManager;
public class CVC5SLFormulaManager extends AbstractSLFormulaManager<Term, Sort, Solver, Term> {
private final Solver solver;
protected CVC5SLFormulaManager(CVC5FormulaCreator pCreator) {
super(pCreator);
solver = pCreator.getEnv();
}
@Override
protected Term makeStar(Term e1, Term e2) {
return solver.mkTerm(Kind.SEP_STAR, e1, e2);
}
@Override
protected Term makePointsTo(Term pPtr, Term pTo) {
return solver.mkTerm(Kind.SEP_PTO, pPtr, pTo);
}
@Override
protected Term makeMagicWand(Term pE1, Term pE2) {
return solver.mkTerm(Kind.SEP_WAND, pE1, pE2);
}
@Override
protected Term makeEmptyHeap(Sort pT1, Sort pT2) {
// According to the documentation this is sortless
return solver.mkTerm(Kind.SEP_EMP);
}
@Override
protected Term makeNilElement(Sort pSort) {
return solver.mkSepNil(pSort);
}
}
| 1,333 | 24.653846 | 94 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5SolverContext.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import io.github.cvc5.Solver;
import java.util.Set;
import java.util.function.Consumer;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.common.log.LogManager;
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.api.SolverContext;
import org.sosy_lab.java_smt.basicimpl.AbstractNumeralFormulaManager.NonLinearArithmetic;
import org.sosy_lab.java_smt.basicimpl.AbstractSolverContext;
public final class CVC5SolverContext extends AbstractSolverContext {
// creator is final, except after closing, then null.
private CVC5FormulaCreator creator;
private final Solver solver;
private final ShutdownNotifier shutdownNotifier;
private final int randomSeed;
private boolean closed = false;
private CVC5SolverContext(
CVC5FormulaCreator pCreator,
CVC5FormulaManager manager,
ShutdownNotifier pShutdownNotifier,
Solver pSolver,
int pRandomSeed) {
super(manager);
creator = pCreator;
shutdownNotifier = pShutdownNotifier;
randomSeed = pRandomSeed;
solver = pSolver;
}
@VisibleForTesting
static void loadLibrary(Consumer<String> pLoader) {
pLoader.accept("cvc5jni");
// disable CVC5's own loading mechanism,
// see io.github.cvc5.Util#loadLibraries and https://github.com/cvc5/cvc5/pull/9047
System.setProperty("cvc5.skipLibraryLoad", "true");
}
@SuppressWarnings({"unused", "resource"})
public static SolverContext create(
LogManager pLogger,
ShutdownNotifier pShutdownNotifier,
int randomSeed,
NonLinearArithmetic pNonLinearArithmetic,
FloatingPointRoundingMode pFloatingPointRoundingMode,
Consumer<String> pLoader) {
loadLibrary(pLoader);
// This Solver is the central class for creating expressions/terms/formulae.
// We keep this instance available until the whole context is closed.
Solver newSolver = new Solver();
setSolverOptions(newSolver, randomSeed);
CVC5FormulaCreator pCreator = new CVC5FormulaCreator(newSolver);
// Create managers
CVC5UFManager functionTheory = new CVC5UFManager(pCreator);
CVC5BooleanFormulaManager booleanTheory = new CVC5BooleanFormulaManager(pCreator);
CVC5IntegerFormulaManager integerTheory =
new CVC5IntegerFormulaManager(pCreator, pNonLinearArithmetic);
CVC5RationalFormulaManager rationalTheory =
new CVC5RationalFormulaManager(pCreator, pNonLinearArithmetic);
CVC5BitvectorFormulaManager bitvectorTheory =
new CVC5BitvectorFormulaManager(pCreator, booleanTheory);
CVC5FloatingPointFormulaManager fpTheory =
new CVC5FloatingPointFormulaManager(pCreator, pFloatingPointRoundingMode);
CVC5QuantifiedFormulaManager qfTheory = new CVC5QuantifiedFormulaManager(pCreator);
CVC5ArrayFormulaManager arrayTheory = new CVC5ArrayFormulaManager(pCreator);
CVC5SLFormulaManager slTheory = new CVC5SLFormulaManager(pCreator);
CVC5StringFormulaManager strTheory = new CVC5StringFormulaManager(pCreator);
CVC5EnumerationFormulaManager enumTheory = new CVC5EnumerationFormulaManager(pCreator);
CVC5FormulaManager manager =
new CVC5FormulaManager(
pCreator,
functionTheory,
booleanTheory,
integerTheory,
rationalTheory,
bitvectorTheory,
fpTheory,
qfTheory,
arrayTheory,
slTheory,
strTheory,
enumTheory);
return new CVC5SolverContext(pCreator, manager, pShutdownNotifier, newSolver, randomSeed);
}
/** Set common options for a CVC5 solver. */
private static void setSolverOptions(Solver pSolver, int randomSeed) {
pSolver.setOption("seed", String.valueOf(randomSeed));
pSolver.setOption("output-language", "smtlib2");
// Set Strings option to enable all String features (such as lessOrEquals).
// This should not have any effect for non-string theories.
// pSolver.setOption("strings-exp", "true");
// pSolver.setOption("finite-model-find", "true");
// pSolver.setOption("sets-ext", "true");
// pSolver.setOption("produce-models", "true");
// pSolver.setOption("produce-unsat-cores", "true");
// Neither simplification, arith-rewrite-equalities, pb-rewrites provide rewrites of trivial
// formulas only.
// Note: with solver.getOptionNames() you can get all options
}
@Override
public String getVersion() {
String version = solver.getInfo("version");
if (version.startsWith("\"") && version.endsWith("\"")) {
version = version.substring(1, version.length() - 1);
}
return "CVC5 " + version;
}
@Override
public void close() {
if (creator != null) {
closed = true;
creator = null;
}
}
@Override
public Solvers getSolverName() {
return Solvers.CVC5;
}
@Override
public ProverEnvironment newProverEnvironment0(Set<ProverOptions> pOptions) {
Preconditions.checkState(!closed, "solver context is already closed");
return new CVC5TheoremProver(
creator, shutdownNotifier, randomSeed, pOptions, getFormulaManager());
}
@Override
protected boolean supportsAssumptionSolving() {
return false;
}
@Override
protected InterpolatingProverEnvironment<?> newProverEnvironmentWithInterpolation0(
Set<ProverOptions> pOptions) {
throw new UnsupportedOperationException("CVC5 does not support Craig interpolation.");
}
@Override
protected OptimizationProverEnvironment newOptimizationProverEnvironment0(
Set<ProverOptions> pSet) {
throw new UnsupportedOperationException("CVC5 does not support optimization");
}
}
| 6,284 | 34.508475 | 96 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5StringFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import com.google.common.base.Preconditions;
import io.github.cvc5.Kind;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import java.util.List;
import org.sosy_lab.java_smt.basicimpl.AbstractStringFormulaManager;
class CVC5StringFormulaManager extends AbstractStringFormulaManager<Term, Sort, Solver, Term> {
private final Solver solver;
CVC5StringFormulaManager(CVC5FormulaCreator pCreator) {
super(pCreator);
solver = pCreator.getEnv();
}
@Override
protected Term makeStringImpl(String pValue) {
return solver.mkString(pValue, true);
}
@Override
protected Term makeVariableImpl(String varName) {
Sort type = getFormulaCreator().getStringType();
return getFormulaCreator().makeVariable(type, varName);
}
@Override
protected Term equal(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.EQUAL, pParam1, pParam2);
}
@Override
protected Term greaterThan(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.STRING_LT, pParam2, pParam1);
}
@Override
protected Term greaterOrEquals(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.STRING_LEQ, pParam2, pParam1);
}
@Override
protected Term lessThan(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.STRING_LT, pParam1, pParam2);
}
@Override
protected Term lessOrEquals(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.STRING_LEQ, pParam1, pParam2);
}
@Override
protected Term length(Term pParam) {
return solver.mkTerm(Kind.STRING_LENGTH, pParam);
}
@Override
protected Term concatImpl(List<Term> parts) {
Preconditions.checkArgument(parts.size() > 1);
return solver.mkTerm(Kind.STRING_CONCAT, parts.toArray(new Term[0]));
}
@Override
protected Term prefix(Term prefix, Term str) {
return solver.mkTerm(Kind.STRING_PREFIX, prefix, str);
}
@Override
protected Term suffix(Term suffix, Term str) {
return solver.mkTerm(Kind.STRING_SUFFIX, suffix, str);
}
@Override
protected Term in(Term str, Term regex) {
return solver.mkTerm(Kind.STRING_IN_REGEXP, str, regex);
}
@Override
protected Term contains(Term str, Term part) {
return solver.mkTerm(Kind.STRING_CONTAINS, str, part);
}
@Override
protected Term indexOf(Term str, Term part, Term startIndex) {
return solver.mkTerm(Kind.STRING_INDEXOF, str, part, startIndex);
}
@Override
protected Term charAt(Term str, Term index) {
return solver.mkTerm(Kind.STRING_CHARAT, str, index);
}
@Override
protected Term substring(Term str, Term index, Term length) {
return solver.mkTerm(Kind.STRING_SUBSTR, str, index, length);
}
@Override
protected Term replace(Term fullStr, Term target, Term replacement) {
return solver.mkTerm(Kind.STRING_REPLACE, fullStr, target, replacement);
}
@Override
protected Term replaceAll(Term fullStr, Term target, Term replacement) {
return solver.mkTerm(Kind.STRING_REPLACE_ALL, fullStr, target, replacement);
}
@Override
protected Term makeRegexImpl(String value) {
Term str = makeStringImpl(value);
return solver.mkTerm(Kind.STRING_TO_REGEXP, str);
}
@Override
protected Term noneImpl() {
return solver.mkTerm(Kind.REGEXP_NONE);
}
@Override
protected Term allImpl() {
return solver.mkTerm(Kind.REGEXP_COMPLEMENT, noneImpl());
}
@Override
protected Term allCharImpl() {
return solver.mkTerm(Kind.REGEXP_ALLCHAR);
}
@Override
protected Term range(Term start, Term end) {
return solver.mkTerm(Kind.REGEXP_RANGE, start, end);
}
@Override
protected Term concatRegexImpl(List<Term> parts) {
Preconditions.checkArgument(parts.size() > 1);
return solver.mkTerm(Kind.REGEXP_CONCAT, parts.toArray(new Term[0]));
}
@Override
protected Term union(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.REGEXP_UNION, pParam1, pParam2);
}
@Override
protected Term intersection(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.REGEXP_INTER, pParam1, pParam2);
}
@Override
protected Term closure(Term pParam) {
return solver.mkTerm(Kind.REGEXP_STAR, pParam);
}
@Override
protected Term complement(Term pParam) {
return solver.mkTerm(Kind.REGEXP_COMPLEMENT, pParam);
}
@Override
protected Term difference(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.REGEXP_DIFF, pParam1, pParam2);
}
@Override
protected Term toIntegerFormula(Term pParam) {
return solver.mkTerm(Kind.STRING_TO_INT, pParam);
}
@Override
protected Term toStringFormula(Term pParam) {
Preconditions.checkArgument(
pParam.getSort().equals(solver.getIntegerSort()) || pParam.isIntegerValue(),
"CVC5 only supports INT to STRING conversion.");
return solver.mkTerm(Kind.STRING_FROM_INT, pParam);
}
}
| 5,099 | 25.842105 | 95 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5TheoremProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import java.util.Set;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.java_smt.api.BasicProverEnvironment;
import org.sosy_lab.java_smt.api.FormulaManager;
import org.sosy_lab.java_smt.api.ProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
class CVC5TheoremProver extends CVC5AbstractProver<Void>
implements ProverEnvironment, BasicProverEnvironment<Void> {
protected CVC5TheoremProver(
CVC5FormulaCreator pFormulaCreator,
ShutdownNotifier pShutdownNotifier,
@SuppressWarnings("unused") int randomSeed,
Set<ProverOptions> pOptions,
FormulaManager pMgr) {
super(pFormulaCreator, pShutdownNotifier, randomSeed, pOptions, pMgr);
}
}
| 1,006 | 32.566667 | 74 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5UFManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc5;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import org.sosy_lab.java_smt.basicimpl.AbstractUFManager;
class CVC5UFManager extends AbstractUFManager<Term, Term, Sort, Solver> {
CVC5UFManager(CVC5FormulaCreator pCreator) {
super(pCreator);
}
}
| 579 | 25.363636 | 73 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/package-info.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
/** Interface to the SMT solver CVC5 (based on CVC5's Java bindings). */
package org.sosy_lab.java_smt.solvers.cvc5;
| 357 | 31.545455 | 72 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5AbstractNativeApiTest.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static com.google.common.truth.Truth.assertThat;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_assert_formula;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_check_sat;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_declare_function;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_destroy_env;
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_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_integer_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_make_bv_number;
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_equal;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_int_modular_congruence;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_number;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_pop_backtrack_point;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_push_backtrack_point;
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_repr;
import org.junit.After;
import org.junit.Ignore;
import org.junit.Test;
import org.sosy_lab.java_smt.api.SolverException;
@Ignore("prevent this abstract class being executed as testcase by ant")
public abstract class Mathsat5AbstractNativeApiTest {
protected long env;
@After
public void freeEnvironment() {
msat_destroy_env(env);
}
@Test
public void bvSize() {
long number = msat_make_bv_number(env, "42", 32, 10);
long type = msat_term_get_type(number);
assertThat(msat_is_bv_type(env, type)).isTrue();
assertThat(msat_get_bv_type_size(env, type)).isEqualTo(32);
long funcDecl = msat_declare_function(env, "testVar", type);
long var = msat_make_constant(env, funcDecl);
type = msat_term_get_type(var);
assertThat(msat_is_bv_type(env, type)).isTrue();
assertThat(msat_get_bv_type_size(env, type)).isEqualTo(32);
}
@Test
public void fpExpWidth() {
long type = msat_get_fp_type(env, 8, 23);
assertThat(msat_get_fp_type_exp_width(env, type)).isEqualTo(8);
}
@Test
public void fpMantWidth() {
long type = msat_get_fp_type(env, 8, 23);
assertThat(msat_get_fp_type_mant_width(env, type)).isEqualTo(23);
}
@Test(expected = IllegalArgumentException.class)
@SuppressWarnings("CheckReturnValue")
public void fpExpWidthIllegal() {
long type = msat_get_integer_type(env);
msat_get_fp_type_exp_width(env, type);
}
@Test
public void modularCongruence()
throws InterruptedException, IllegalStateException, SolverException {
long type = msat_get_integer_type(env);
long v1 = msat_declare_function(env, "v1", type);
long t1 = msat_make_constant(env, v1);
long v2 = msat_declare_function(env, "v2", type);
long t2 = msat_make_constant(env, v2);
long t = msat_make_int_modular_congruence(env, "42", t1, t2);
assertThat(msat_term_repr(t)).isEqualTo("(`int_mod_congr_42` (`+_int` v1 (`*_int` -1 v2)) 0)");
msat_assert_formula(env, t);
msat_push_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, t1, msat_make_number(env, "3")));
msat_assert_formula(env, msat_make_equal(env, t2, msat_make_number(env, "45")));
assertThat(msat_check_sat(env)).isTrue(); // 3 == 45 mod 42
msat_pop_backtrack_point(env);
msat_push_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, t1, msat_make_number(env, "45")));
msat_assert_formula(env, msat_make_equal(env, t2, msat_make_number(env, "45")));
assertThat(msat_check_sat(env)).isTrue(); // 45 == 45 mod 42 according to Mathsat
msat_pop_backtrack_point(env);
msat_push_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, t1, msat_make_number(env, "87")));
msat_assert_formula(env, msat_make_equal(env, t2, msat_make_number(env, "45")));
assertThat(msat_check_sat(env)).isTrue(); // 87 == 45 mod 42 according to Mathsat
msat_pop_backtrack_point(env);
msat_push_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, t1, msat_make_number(env, "4")));
msat_assert_formula(env, msat_make_equal(env, t2, msat_make_number(env, "45")));
assertThat(msat_check_sat(env)).isFalse(); // 4 != 45 mod 42
msat_pop_backtrack_point(env);
}
}
| 5,353 | 42.528455 | 104 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5AbstractProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5FormulaManager.getMsatTerm;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_all_sat;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_check_sat;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_check_sat_with_assumptions;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_create_config;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_destroy_config;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_destroy_env;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_free_termination_callback;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_search_stats;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_unsat_assumptions;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_unsat_core;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_last_error_message;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_num_backtrack_points;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_pop_backtrack_point;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_set_option_checked;
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_is_boolean_constant;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_is_not;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.primitives.Longs;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.Evaluator;
import org.sosy_lab.java_smt.api.Model;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
import org.sosy_lab.java_smt.basicimpl.AbstractProver;
import org.sosy_lab.java_smt.basicimpl.CachingModel;
import org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.AllSatModelCallback;
/** Common base class for {@link Mathsat5TheoremProver} and {@link Mathsat5InterpolatingProver}. */
abstract class Mathsat5AbstractProver<T2> extends AbstractProver<T2> {
protected final Mathsat5SolverContext context;
protected final long curEnv;
private final long curConfig;
private final long terminationTest;
protected final Mathsat5FormulaCreator creator;
protected boolean closed = false;
private final ShutdownNotifier shutdownNotifier;
protected Mathsat5AbstractProver(
Mathsat5SolverContext pContext,
Set<ProverOptions> pOptions,
Mathsat5FormulaCreator pCreator,
ShutdownNotifier pShutdownNotifier) {
super(pOptions);
context = pContext;
creator = pCreator;
curConfig = buildConfig(pOptions);
curEnv = context.createEnvironment(curConfig);
terminationTest = context.addTerminationTest(curEnv);
shutdownNotifier = pShutdownNotifier;
}
private long buildConfig(Set<ProverOptions> opts) {
Map<String, String> config = new LinkedHashMap<>();
boolean generateUnsatCore =
opts.contains(ProverOptions.GENERATE_UNSAT_CORE)
|| opts.contains(ProverOptions.GENERATE_UNSAT_CORE_OVER_ASSUMPTIONS);
config.put("model_generation", opts.contains(ProverOptions.GENERATE_MODELS) ? "true" : "false");
config.put("unsat_core_generation", generateUnsatCore ? "1" : "0");
if (generateUnsatCore) {
config.put("theory.bv.eager", "false");
}
createConfig(config); // ask sub-classes for their options
long cfg = msat_create_config();
for (Map.Entry<String, String> entry : config.entrySet()) {
msat_set_option_checked(cfg, entry.getKey(), entry.getValue());
}
return cfg;
}
/** add needed options into the given map. */
protected abstract void createConfig(Map<String, String> pConfig);
@Override
public boolean isUnsat() throws InterruptedException, SolverException {
Preconditions.checkState(!closed);
return !msat_check_sat(curEnv);
}
@Override
public boolean isUnsatWithAssumptions(Collection<BooleanFormula> pAssumptions)
throws SolverException, InterruptedException {
Preconditions.checkState(!closed);
checkForLiterals(pAssumptions);
return !msat_check_sat_with_assumptions(curEnv, getMsatTerm(pAssumptions));
}
private void checkForLiterals(Collection<BooleanFormula> formulas) {
for (BooleanFormula f : formulas) {
long t = getMsatTerm(f);
if (msat_term_is_boolean_constant(curEnv, t)) {
// boolean constant is valid
} else if (msat_term_is_not(curEnv, t)
&& msat_term_is_boolean_constant(curEnv, msat_term_get_arg(t, 0))) {
// negated boolean constant is valid
} else {
throw new UnsupportedOperationException("formula is not a (negated) literal: " + f);
}
}
}
@SuppressWarnings("resource")
@Override
public Model getModel() throws SolverException {
Preconditions.checkState(!closed);
checkGenerateModels();
return new CachingModel(new Mathsat5Model(getMsatModel(), creator, this));
}
/**
* @throws SolverException if an expected MathSAT failure occurs
*/
protected long getMsatModel() throws SolverException {
checkGenerateModels();
return Mathsat5NativeApi.msat_get_model(curEnv);
}
@SuppressWarnings("resource")
@Override
public Evaluator getEvaluator() {
Preconditions.checkState(!closed);
checkGenerateModels();
return registerEvaluator(new Mathsat5Evaluator(this, creator, curEnv));
}
@Override
public void pop() {
Preconditions.checkState(!closed);
closeAllEvaluators();
msat_pop_backtrack_point(curEnv);
}
@Override
public int size() {
Preconditions.checkState(!closed);
return msat_num_backtrack_points(curEnv);
}
@Override
public List<BooleanFormula> getUnsatCore() {
Preconditions.checkState(!closed);
checkGenerateUnsatCores();
long[] terms = msat_get_unsat_core(curEnv);
return encapsulate(terms);
}
@Override
public Optional<List<BooleanFormula>> unsatCoreOverAssumptions(
Collection<BooleanFormula> assumptions) throws SolverException, InterruptedException {
Preconditions.checkNotNull(assumptions);
closeAllEvaluators();
if (!isUnsatWithAssumptions(assumptions)) {
return Optional.empty();
}
long[] unsatAssumptions = msat_get_unsat_assumptions(curEnv);
return Optional.of(encapsulate(unsatAssumptions));
}
private List<BooleanFormula> encapsulate(long[] terms) {
List<BooleanFormula> result = new ArrayList<>(terms.length);
for (long t : terms) {
result.add(creator.encapsulateBoolean(t));
}
return result;
}
@Override
public ImmutableMap<String, String> getStatistics() {
// Mathsat sigsevs if you try to get statistics for closed environments
Preconditions.checkState(!closed);
final String stats = msat_get_search_stats(curEnv);
return ImmutableMap.copyOf(
Splitter.on("\n").trimResults().omitEmptyStrings().withKeyValueSeparator(" ").split(stats));
}
@Override
public void close() {
if (!closed) {
msat_destroy_env(curEnv);
msat_free_termination_callback(terminationTest);
msat_destroy_config(curConfig);
closed = true;
}
super.close();
}
@Override
public <T> T allSat(AllSatCallback<T> callback, List<BooleanFormula> important)
throws InterruptedException, SolverException {
Preconditions.checkState(!closed);
checkGenerateAllSat();
closeAllEvaluators();
long[] imp = new long[important.size()];
int i = 0;
for (BooleanFormula impF : important) {
imp[i++] = getMsatTerm(impF);
}
MathsatAllSatCallback<T> uCallback = new MathsatAllSatCallback<>(callback);
push();
int numModels = msat_all_sat(curEnv, imp, uCallback);
pop();
if (numModels == -1) {
throw new SolverException(
"Error occurred during Mathsat allsat: " + msat_last_error_message(curEnv));
} else if (numModels == -2) {
// Formula is trivially tautological.
// With the current API, we have no way of signaling this except by iterating over all 2^n
// models, which is probably not what we want.
throw new UnsupportedOperationException("allSat for trivially tautological formula");
}
return callback.getResult();
}
class MathsatAllSatCallback<T> implements AllSatModelCallback {
private final AllSatCallback<T> clientCallback;
MathsatAllSatCallback(AllSatCallback<T> pClientCallback) {
clientCallback = pClientCallback;
}
@Override
public void callback(long[] model) throws InterruptedException {
shutdownNotifier.shutdownIfNecessary();
clientCallback.apply(
Collections.unmodifiableList(
Lists.transform(Longs.asList(model), creator::encapsulateBoolean)));
}
}
}
| 9,773 | 36.448276 | 103 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5ArrayFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_array_read;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_array_write;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_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;
class Mathsat5ArrayFormulaManager extends AbstractArrayFormulaManager<Long, Long, Long, Long> {
private final long mathsatEnv;
Mathsat5ArrayFormulaManager(Mathsat5FormulaCreator pCreator) {
super(pCreator);
this.mathsatEnv = pCreator.getEnv();
}
@Override
protected Long select(Long pArray, Long pIndex) {
return msat_make_array_read(mathsatEnv, pArray, pIndex);
}
@Override
protected Long store(Long pArray, Long pIndex, Long pValue) {
return msat_make_array_write(mathsatEnv, pArray, pIndex, pValue);
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TI extends Formula, TE extends Formula> Long internalMakeArray(
String pName, FormulaType<TI> pIndexType, FormulaType<TE> pElementType) {
// throw new UnsupportedOperationException("Please implement me!");
final ArrayFormulaType<TI, TE> arrayFormulaType =
FormulaType.getArrayType(pIndexType, pElementType);
final Long mathsatArrayType = toSolverType(arrayFormulaType);
return getFormulaCreator().makeVariable(mathsatArrayType, pName);
}
@Override
protected Long equivalence(Long pArray1, Long pArray2) {
return msat_make_equal(mathsatEnv, pArray1, pArray2);
}
}
| 2,008 | 34.875 | 95 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5BitvectorFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_and;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_ashr;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_concat;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_extract;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_lshl;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_lshr;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_minus;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_neg;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_not;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_number;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_or;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_plus;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_sdiv;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_sext;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_sleq;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_slt;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_srem;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_times;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_udiv;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_uleq;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_ult;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_urem;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_xor;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_bv_zext;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_equal;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_int_from_sbv;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_int_from_ubv;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_int_to_bv;
import java.math.BigInteger;
import org.sosy_lab.java_smt.basicimpl.AbstractBitvectorFormulaManager;
/** Mathsat Bitvector Theory, build out of Bitvector*Operations. */
class Mathsat5BitvectorFormulaManager
extends AbstractBitvectorFormulaManager<Long, Long, Long, Long> {
private final long mathsatEnv;
protected Mathsat5BitvectorFormulaManager(
Mathsat5FormulaCreator pCreator, Mathsat5BooleanFormulaManager pBmgr) {
super(pCreator, pBmgr);
this.mathsatEnv = pCreator.getEnv();
}
@Override
public Long concat(Long pFirst, Long pSecond) {
return msat_make_bv_concat(mathsatEnv, pFirst, pSecond);
}
@Override
public Long extract(Long pFirst, int pMsb, int pLsb) {
return msat_make_bv_extract(mathsatEnv, pMsb, pLsb, pFirst);
}
@Override
public Long extend(Long pNumber, int pExtensionBits, boolean pSigned) {
if (pSigned) {
return msat_make_bv_sext(mathsatEnv, pExtensionBits, pNumber);
} else {
return msat_make_bv_zext(mathsatEnv, pExtensionBits, pNumber);
}
}
@Override
public Long makeBitvectorImpl(int pLength, long pI) {
int i = (int) pI;
if (i == pI && i > 0) { // fits into an int
return Mathsat5NativeApi.msat_make_bv_int_number(mathsatEnv, i, pLength);
}
return makeBitvectorImpl(pLength, BigInteger.valueOf(pI));
}
@Override
public Long makeBitvectorImpl(int pLength, BigInteger pI) {
pI = transformValueToRange(pLength, pI);
return msat_make_bv_number(mathsatEnv, pI.toString(), pLength, 10);
}
@Override
protected Long makeBitvectorImpl(int pLength, Long pIntegerFormula) {
return msat_make_int_to_bv(mathsatEnv, pLength, pIntegerFormula);
}
@Override
protected Long toIntegerFormulaImpl(Long pBVFormula, boolean pSigned) {
if (pSigned) {
return msat_make_int_from_sbv(mathsatEnv, pBVFormula);
} else {
return msat_make_int_from_ubv(mathsatEnv, pBVFormula);
}
}
@Override
public Long makeVariableImpl(int length, String var) {
long bvType = getFormulaCreator().getBitvectorType(length);
return getFormulaCreator().makeVariable(bvType, var);
}
/**
* Return a term representing the (arithmetic if signed is true) right shift of number by toShift.
*/
@Override
public Long shiftRight(Long number, Long toShift, boolean signed) {
long t;
if (signed) {
t = msat_make_bv_ashr(mathsatEnv, number, toShift);
} else {
t = msat_make_bv_lshr(mathsatEnv, number, toShift);
}
return t;
}
@Override
public Long shiftLeft(Long number, Long toShift) {
return msat_make_bv_lshl(mathsatEnv, number, toShift);
}
@Override
public Long not(Long pBits) {
return msat_make_bv_not(mathsatEnv, pBits);
}
@Override
public Long and(Long pBits1, Long pBits2) {
return msat_make_bv_and(mathsatEnv, pBits1, pBits2);
}
@Override
public Long or(Long pBits1, Long pBits2) {
return msat_make_bv_or(mathsatEnv, pBits1, pBits2);
}
@Override
public Long xor(Long pBits1, Long pBits2) {
return msat_make_bv_xor(mathsatEnv, pBits1, pBits2);
}
@Override
public Long negate(Long pNumber) {
return msat_make_bv_neg(mathsatEnv, pNumber);
}
@Override
public Long add(Long pNumber1, Long pNumber2) {
return msat_make_bv_plus(mathsatEnv, pNumber1, pNumber2);
}
@Override
public Long subtract(Long pNumber1, Long pNumber2) {
return msat_make_bv_minus(mathsatEnv, pNumber1, pNumber2);
}
@Override
public Long divide(Long pNumber1, Long pNumber2, boolean signed) {
if (signed) {
return msat_make_bv_sdiv(mathsatEnv, pNumber1, pNumber2);
} else {
return msat_make_bv_udiv(mathsatEnv, pNumber1, pNumber2);
}
}
@Override
public Long modulo(Long pNumber1, Long pNumber2, boolean signed) {
if (signed) {
return msat_make_bv_srem(mathsatEnv, pNumber1, pNumber2);
} else {
return msat_make_bv_urem(mathsatEnv, pNumber1, pNumber2);
}
}
@Override
public Long multiply(Long pNumber1, Long pNumber2) {
return msat_make_bv_times(mathsatEnv, pNumber1, pNumber2);
}
@Override
public Long equal(Long pNumber1, Long pNumber2) {
return msat_make_equal(mathsatEnv, pNumber1, pNumber2);
}
@Override
public Long lessThan(Long pNumber1, Long pNumber2, boolean signed) {
if (signed) {
return msat_make_bv_slt(mathsatEnv, pNumber1, pNumber2);
} else {
return msat_make_bv_ult(mathsatEnv, pNumber1, pNumber2);
}
}
@Override
public Long lessOrEquals(Long pNumber1, Long pNumber2, boolean signed) {
if (signed) {
return msat_make_bv_sleq(mathsatEnv, pNumber1, pNumber2);
} else {
return msat_make_bv_uleq(mathsatEnv, pNumber1, pNumber2);
}
}
@Override
public Long greaterThan(Long pNumber1, Long pNumber2, boolean signed) {
return lessThan(pNumber2, pNumber1, signed);
}
@Override
public Long greaterOrEquals(Long pNumber1, Long pNumber2, boolean signed) {
return lessOrEquals(pNumber2, pNumber1, signed);
}
}
| 7,853 | 34.863014 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5BooleanFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
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_make_and;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_false;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_iff;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_not;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_or;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_term_ite;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_true;
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_false;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_is_true;
import org.sosy_lab.java_smt.basicimpl.AbstractBooleanFormulaManager;
class Mathsat5BooleanFormulaManager extends AbstractBooleanFormulaManager<Long, Long, Long, Long> {
private final long mathsatEnv;
protected Mathsat5BooleanFormulaManager(Mathsat5FormulaCreator pCreator) {
super(pCreator);
this.mathsatEnv = pCreator.getEnv();
}
@Override
public Long makeVariableImpl(String pVar) {
long boolType = getFormulaCreator().getBoolType();
return getFormulaCreator().makeVariable(boolType, pVar);
}
@Override
public Long makeBooleanImpl(boolean pValue) {
long v;
if (pValue) {
v = msat_make_true(mathsatEnv);
} else {
v = msat_make_false(mathsatEnv);
}
return v;
}
@Override
public Long equivalence(Long f1, Long f2) {
return msat_make_iff(mathsatEnv, f1, f2);
}
@Override
public boolean isTrue(Long t) {
return msat_term_is_true(mathsatEnv, t);
}
@Override
public boolean isFalse(Long t) {
return msat_term_is_false(mathsatEnv, t);
}
@Override
public Long ifThenElse(Long cond, Long f1, Long f2) {
if (isTrue(cond)) {
return f1;
} else if (isFalse(cond)) {
return f2;
} else if (f1.equals(f2)) {
return f1;
} else if (isTrue(f1) && isFalse(f2)) {
return cond;
} else if (isFalse(f1) && isTrue(f2)) {
return not(cond);
}
long t;
long msatEnv = mathsatEnv;
long f1Type = msat_term_get_type(f1);
long f2Type = msat_term_get_type(f2);
// ite does not allow boolean arguments
if (!msat_is_bool_type(msatEnv, f1Type) || !msat_is_bool_type(msatEnv, f2Type)) {
t = msat_make_term_ite(msatEnv, cond, f1, f2);
} else {
t =
msat_make_and(
msatEnv,
msat_make_or(msatEnv, msat_make_not(msatEnv, cond), f1),
msat_make_or(msatEnv, cond, f2));
}
return t;
}
@Override
public Long not(Long pBits) {
return msat_make_not(mathsatEnv, pBits);
}
@Override
public Long and(Long pBits1, Long pBits2) {
return msat_make_and(mathsatEnv, pBits1, pBits2);
}
@Override
public Long or(Long pBits1, Long pBits2) {
return msat_make_or(mathsatEnv, pBits1, pBits2);
}
@Override
public Long xor(Long pBits1, Long pBits2) {
return not(msat_make_iff(mathsatEnv, pBits1, pBits2));
}
}
| 3,619 | 29.420168 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5EnumerationFormulaManager.java | // 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 <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
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_enum_type;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_equal;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_term;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import org.sosy_lab.java_smt.api.FormulaType.EnumerationFormulaType;
import org.sosy_lab.java_smt.basicimpl.AbstractEnumerationFormulaManager;
import org.sosy_lab.java_smt.basicimpl.FormulaCreator;
public class Mathsat5EnumerationFormulaManager
extends AbstractEnumerationFormulaManager<Long, Long, Long, Long> {
private final long mathsatEnv;
protected Mathsat5EnumerationFormulaManager(FormulaCreator<Long, Long, Long, Long> pCreator) {
super(pCreator);
this.mathsatEnv = pCreator.getEnv();
}
@Override
protected EnumType declareEnumeration0(EnumerationFormulaType pType) {
// MathSAT does not support equal-named enumeration elements in distinct enumeration types.
for (EnumType existingType : enumerations.values()) {
Preconditions.checkArgument(
Iterables.all(pType.getElements(), e -> !existingType.hasConstants(e)),
"Enumeration type '%s' has elements that already appear in enumeration type '%s'.",
pType,
existingType.getEnumerationFormulaType());
}
String[] elements = pType.getElements().toArray(new String[] {});
long enumType = msat_get_enum_type(mathsatEnv, pType.getName(), elements.length, elements);
// we store the constants for later access
long[] constantDecls = msat_get_enum_constants(mathsatEnv, enumType);
ImmutableMap.Builder<String, Long> constantsMapping = ImmutableMap.builder();
for (int i = 0; i < elements.length; i++) {
long constant = msat_make_term(mathsatEnv, constantDecls[i], new long[] {});
constantsMapping.put(elements[i], constant);
}
return new EnumType(pType, enumType, constantsMapping.buildOrThrow());
}
@Override
protected Long equivalenceImpl(Long pF1, Long pF2) {
return msat_make_equal(mathsatEnv, pF1, pF2);
}
}
| 2,594 | 40.190476 | 96 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5Evaluator.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2022 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_model_value;
import com.google.common.base.Preconditions;
import org.sosy_lab.java_smt.basicimpl.AbstractEvaluator;
import org.sosy_lab.java_smt.basicimpl.AbstractProver;
/** This class requires an option for MathSAT: model_generation=true. TODO option does not work? */
class Mathsat5Evaluator extends AbstractEvaluator<Long, Long, Long> {
private final long proverEnvironment;
Mathsat5Evaluator(
AbstractProver<?> prover, Mathsat5FormulaCreator creator, long pProverEnvironment) {
super(prover, creator);
proverEnvironment = pProverEnvironment;
}
@Override
protected Long evalImpl(Long formula) {
Preconditions.checkState(!isClosed());
return msat_get_model_value(proverEnvironment, formula);
}
}
| 1,107 | 31.588235 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5FloatingPointFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_equal;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_abs;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_cast;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_div;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_equal;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_from_sbv;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_from_ubv;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_isinf;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_isnan;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_isneg;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_isnormal;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_issubnormal;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_iszero;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_leq;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_lt;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_max;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_min;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_minus;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_minus_inf;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_nan;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_neg;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_plus;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_plus_inf;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_rat_number;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_round_to_int;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_roundingmode_minus_inf;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_roundingmode_nearest_even;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_roundingmode_plus_inf;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_roundingmode_zero;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_sqrt;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_times;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_to_sbv;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_fp_to_ubv;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_uf;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_get_type;
import com.google.common.collect.ImmutableList;
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;
class Mathsat5FloatingPointFormulaManager
extends AbstractFloatingPointFormulaManager<Long, Long, Long, Long> {
private final long mathsatEnv;
private final long roundingMode;
Mathsat5FloatingPointFormulaManager(
Mathsat5FormulaCreator pCreator, FloatingPointRoundingMode pFloatingPointRoundingMode) {
super(pCreator);
mathsatEnv = pCreator.getEnv();
roundingMode = getRoundingModeImpl(pFloatingPointRoundingMode);
}
@Override
protected Long getDefaultRoundingMode() {
return roundingMode;
}
@Override
protected Long getRoundingModeImpl(FloatingPointRoundingMode pFloatingPointRoundingMode) {
switch (pFloatingPointRoundingMode) {
case NEAREST_TIES_TO_EVEN:
return msat_make_fp_roundingmode_nearest_even(mathsatEnv);
case NEAREST_TIES_AWAY:
throw new IllegalArgumentException(
"Rounding mode NEAREST_TIES_AWAY is not supported by Mathsat5");
case TOWARD_POSITIVE:
return msat_make_fp_roundingmode_plus_inf(mathsatEnv);
case TOWARD_NEGATIVE:
return msat_make_fp_roundingmode_minus_inf(mathsatEnv);
case TOWARD_ZERO:
return msat_make_fp_roundingmode_zero(mathsatEnv);
default:
throw new AssertionError("Unexpected branch");
}
}
@Override
protected Long makeNumberImpl(double pN, FloatingPointType pType, Long pRoundingMode) {
return makeNumberImpl(Double.toString(pN), pType, pRoundingMode);
}
@Override
protected Long makeNumberAndRound(String pN, FloatingPointType pType, Long pRoundingMode) {
try {
if (isNegativeZero(Double.valueOf(pN))) {
return msat_make_fp_neg(
mathsatEnv,
msat_make_fp_rat_number(
mathsatEnv, "0", pType.getExponentSize(), pType.getMantissaSize(), pRoundingMode));
}
} catch (NumberFormatException e) {
// ignore and fallback to floating point from rational numbers
}
return msat_make_fp_rat_number(
mathsatEnv, pN, pType.getExponentSize(), pType.getMantissaSize(), pRoundingMode);
}
@Override
protected Long makeVariableImpl(String var, FloatingPointType type) {
return getFormulaCreator().makeVariable(getFormulaCreator().getFloatingPointType(type), var);
}
@Override
protected Long makePlusInfinityImpl(FloatingPointType type) {
return msat_make_fp_plus_inf(mathsatEnv, type.getExponentSize(), type.getMantissaSize());
}
@Override
protected Long makeMinusInfinityImpl(FloatingPointType type) {
return msat_make_fp_minus_inf(mathsatEnv, type.getExponentSize(), type.getMantissaSize());
}
@Override
protected Long makeNaNImpl(FloatingPointType type) {
return msat_make_fp_nan(mathsatEnv, type.getExponentSize(), type.getMantissaSize());
}
@Override
protected Long castToImpl(
Long pNumber, boolean pSigned, FormulaType<?> pTargetType, Long pRoundingMode) {
if (pTargetType.isFloatingPointType()) {
FormulaType.FloatingPointType targetType = (FormulaType.FloatingPointType) pTargetType;
return msat_make_fp_cast(
mathsatEnv,
targetType.getExponentSize(),
targetType.getMantissaSize(),
pRoundingMode,
pNumber);
} else if (pTargetType.isBitvectorType()) {
FormulaType.BitvectorType targetType = (FormulaType.BitvectorType) pTargetType;
if (pSigned) {
return msat_make_fp_to_sbv(mathsatEnv, targetType.getSize(), pRoundingMode, pNumber);
} else {
return msat_make_fp_to_ubv(mathsatEnv, targetType.getSize(), pRoundingMode, pNumber);
}
} else {
return genericCast(pNumber, pTargetType);
}
}
@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 msat_make_fp_from_sbv(
mathsatEnv,
pTargetType.getExponentSize(),
pTargetType.getMantissaSize(),
pRoundingMode,
pNumber);
} else {
return msat_make_fp_from_ubv(
mathsatEnv,
pTargetType.getExponentSize(),
pTargetType.getMantissaSize(),
pRoundingMode,
pNumber);
}
} else {
return genericCast(pNumber, pTargetType);
}
}
private Long genericCast(Long pNumber, FormulaType<?> pTargetType) {
long msatArgType = msat_term_get_type(pNumber);
FormulaType<?> argType = getFormulaCreator().getFormulaType(pNumber);
long castFuncDecl =
getFormulaCreator()
.declareUFImpl(
"__cast_" + argType + "_to_" + pTargetType,
toSolverType(pTargetType),
ImmutableList.of(msatArgType));
return msat_make_uf(mathsatEnv, castFuncDecl, new long[] {pNumber});
}
@Override
protected Long fromIeeeBitvectorImpl(Long pNumber, FloatingPointType pTargetType) {
return Mathsat5NativeApi.msat_make_fp_from_ieeebv(
mathsatEnv, pTargetType.getExponentSize(), pTargetType.getMantissaSize(), pNumber);
}
@Override
protected Long toIeeeBitvectorImpl(Long pNumber) {
return Mathsat5NativeApi.msat_make_fp_as_ieeebv(mathsatEnv, pNumber);
}
@Override
protected Long negate(Long pNumber) {
return msat_make_fp_neg(mathsatEnv, pNumber);
}
@Override
protected Long abs(Long pNumber) {
return msat_make_fp_abs(mathsatEnv, pNumber);
}
@Override
protected Long max(Long pNumber1, Long pNumber2) {
return msat_make_fp_max(mathsatEnv, pNumber1, pNumber2);
}
@Override
protected Long min(Long pNumber1, Long pNumber2) {
return msat_make_fp_min(mathsatEnv, pNumber1, pNumber2);
}
@Override
protected Long sqrt(Long pNumber, Long pRoundingMode) {
return msat_make_fp_sqrt(mathsatEnv, pRoundingMode, pNumber);
}
@Override
protected Long add(Long pNumber1, Long pNumber2, Long pRoundingMode) {
return msat_make_fp_plus(mathsatEnv, pRoundingMode, pNumber1, pNumber2);
}
@Override
protected Long subtract(Long pNumber1, Long pNumber2, Long pRoundingMode) {
return msat_make_fp_minus(mathsatEnv, pRoundingMode, pNumber1, pNumber2);
}
@Override
protected Long multiply(Long pNumber1, Long pNumber2, Long pRoundingMode) {
return msat_make_fp_times(mathsatEnv, pRoundingMode, pNumber1, pNumber2);
}
@Override
protected Long divide(Long pNumber1, Long pNumber2, Long pRoundingMode) {
return msat_make_fp_div(mathsatEnv, pRoundingMode, pNumber1, pNumber2);
}
@Override
protected Long assignment(Long pNumber1, Long pNumber2) {
return msat_make_equal(mathsatEnv, pNumber1, pNumber2);
}
@Override
protected Long equalWithFPSemantics(Long pNumber1, Long pNumber2) {
return msat_make_fp_equal(mathsatEnv, pNumber1, pNumber2);
}
@Override
protected Long greaterThan(Long pNumber1, Long pNumber2) {
return lessThan(pNumber2, pNumber1);
}
@Override
protected Long greaterOrEquals(Long pNumber1, Long pNumber2) {
return lessOrEquals(pNumber2, pNumber1);
}
@Override
protected Long lessThan(Long pNumber1, Long pNumber2) {
return msat_make_fp_lt(mathsatEnv, pNumber1, pNumber2);
}
@Override
protected Long lessOrEquals(Long pNumber1, Long pNumber2) {
return msat_make_fp_leq(mathsatEnv, pNumber1, pNumber2);
}
@Override
protected Long isNaN(Long pParam) {
return msat_make_fp_isnan(mathsatEnv, pParam);
}
@Override
protected Long isInfinity(Long pParam) {
return msat_make_fp_isinf(mathsatEnv, pParam);
}
@Override
protected Long isZero(Long pParam) {
return msat_make_fp_iszero(mathsatEnv, pParam);
}
@Override
protected Long isSubnormal(Long pParam) {
return msat_make_fp_issubnormal(mathsatEnv, pParam);
}
@Override
protected Long isNormal(Long pParam) {
return msat_make_fp_isnormal(mathsatEnv, pParam);
}
@Override
protected Long isNegative(Long pParam) {
return msat_make_fp_isneg(mathsatEnv, pParam);
}
@Override
protected Long round(Long pFormula, FloatingPointRoundingMode pRoundingMode) {
return msat_make_fp_round_to_int(mathsatEnv, getRoundingModeImpl(pRoundingMode), pFormula);
}
}
| 12,254 | 37.17757 | 110 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5Formula.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
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.EnumerationFormula;
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.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.NumeralFormula.RationalFormula;
@Immutable
abstract class Mathsat5Formula implements Formula {
private final long msatTerm;
Mathsat5Formula(long term) {
this.msatTerm = term;
}
@Override
public final String toString() {
return Mathsat5NativeApi.msat_term_repr(msatTerm);
}
@Override
public final boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof Mathsat5Formula)) {
return false;
}
return msatTerm == ((Mathsat5Formula) o).msatTerm;
}
@Override
public final int hashCode() {
return (int) msatTerm;
}
final long getTerm() {
return msatTerm;
}
@Immutable
@SuppressWarnings("ClassTypeParameterName")
static final class Mathsat5ArrayFormula<TI extends Formula, TE extends Formula>
extends Mathsat5Formula implements ArrayFormula<TI, TE> {
private final FormulaType<TI> indexType;
private final FormulaType<TE> elementType;
Mathsat5ArrayFormula(long pTerm, FormulaType<TI> pIndexType, FormulaType<TE> pElementType) {
super(pTerm);
indexType = pIndexType;
elementType = pElementType;
}
public FormulaType<TI> getIndexType() {
return indexType;
}
public FormulaType<TE> getElementType() {
return elementType;
}
}
@Immutable
static final class Mathsat5BitvectorFormula extends Mathsat5Formula implements BitvectorFormula {
Mathsat5BitvectorFormula(long pTerm) {
super(pTerm);
}
}
@Immutable
static final class Mathsat5FloatingPointFormula extends Mathsat5Formula
implements FloatingPointFormula {
Mathsat5FloatingPointFormula(long pTerm) {
super(pTerm);
}
}
@Immutable
static final class Mathsat5FloatingPointRoundingModeFormula extends Mathsat5Formula
implements FloatingPointRoundingModeFormula {
Mathsat5FloatingPointRoundingModeFormula(long pTerm) {
super(pTerm);
}
}
@Immutable
static final class Mathsat5IntegerFormula extends Mathsat5Formula implements IntegerFormula {
Mathsat5IntegerFormula(long pTerm) {
super(pTerm);
}
}
@Immutable
static final class Mathsat5RationalFormula extends Mathsat5Formula implements RationalFormula {
Mathsat5RationalFormula(long pTerm) {
super(pTerm);
}
}
@Immutable
static final class Mathsat5BooleanFormula extends Mathsat5Formula implements BooleanFormula {
Mathsat5BooleanFormula(long pTerm) {
super(pTerm);
}
}
@Immutable
static final class Mathsat5EnumerationFormula extends Mathsat5Formula
implements EnumerationFormula {
Mathsat5EnumerationFormula(long pTerm) {
super(pTerm);
}
}
}
| 3,526 | 25.719697 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5FormulaCreator.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
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 com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.primitives.Longs;
import com.google.common.primitives.UnsignedInteger;
import com.google.common.primitives.UnsignedLong;
import java.math.BigInteger;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.sosy_lab.common.rationals.Rational;
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.EnumerationFormula;
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.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.mathsat5.Mathsat5Formula.Mathsat5ArrayFormula;
import org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5Formula.Mathsat5BitvectorFormula;
import org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5Formula.Mathsat5BooleanFormula;
import org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5Formula.Mathsat5EnumerationFormula;
import org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5Formula.Mathsat5FloatingPointFormula;
import org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5Formula.Mathsat5FloatingPointRoundingModeFormula;
import org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5Formula.Mathsat5IntegerFormula;
import org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5Formula.Mathsat5RationalFormula;
class Mathsat5FormulaCreator extends FormulaCreator<Long, Long, Long, Long> {
private static final Pattern FLOATING_POINT_PATTERN = Pattern.compile("^(\\d+)_(\\d+)_(\\d+)$");
private static final Pattern BITVECTOR_PATTERN = Pattern.compile("^(\\d+)_(\\d+)$");
Mathsat5FormulaCreator(final Long msatEnv) {
super(
msatEnv,
msat_get_bool_type(msatEnv),
msat_get_integer_type(msatEnv),
msat_get_rational_type(msatEnv),
null,
null);
}
@Override
public Long makeVariable(Long type, String varName) {
long funcDecl = msat_declare_function(getEnv(), varName, type);
return msat_make_constant(getEnv(), funcDecl);
}
@Override
public Long extractInfo(Formula pT) {
return Mathsat5FormulaManager.getMsatTerm(pT);
}
@SuppressWarnings("unchecked")
@Override
public <T extends Formula> FormulaType<T> getFormulaType(T pFormula) {
long env = getEnv();
long type = msat_term_get_type(extractInfo(pFormula));
if (pFormula instanceof BitvectorFormula) {
if (!msat_is_bv_type(env, type)) {
throw new IllegalArgumentException(
"BitvectorFormula with actual type " + msat_type_repr(type) + ": " + pFormula);
}
return (FormulaType<T>) getFormulaTypeFromTermType(type);
} else if (pFormula instanceof FloatingPointFormula) {
if (!msat_is_fp_type(env, type)) {
throw new IllegalArgumentException(
"FloatingPointFormula with actual type " + msat_type_repr(type) + ": " + pFormula);
}
return (FormulaType<T>) getFormulaTypeFromTermType(type);
} else if (pFormula instanceof ArrayFormula<?, ?>) {
return (FormulaType<T>) getFormulaTypeFromTermType(type);
} else if (pFormula instanceof EnumerationFormula) {
return (FormulaType<T>) getFormulaTypeFromTermType(type);
}
return super.getFormulaType(pFormula);
}
@Override
public FormulaType<?> getFormulaType(Long pFormula) {
long type = msat_term_get_type(pFormula);
return getFormulaTypeFromTermType(type);
}
private FormulaType<?> getFormulaTypeFromTermType(Long type) {
long env = getEnv();
if (msat_is_bool_type(env, type)) {
return FormulaType.BooleanType;
} else if (msat_is_integer_type(env, type)) {
return FormulaType.IntegerType;
} else if (msat_is_rational_type(env, type)) {
return FormulaType.RationalType;
} else if (msat_is_bv_type(env, type)) {
return FormulaType.getBitvectorTypeWithSize(msat_get_bv_type_size(env, type));
} else if (msat_is_fp_type(env, type)) {
return FormulaType.getFloatingPointType(
msat_get_fp_type_exp_width(env, type), msat_get_fp_type_mant_width(env, type));
} else if (msat_is_fp_roundingmode_type(env, type)) {
return FormulaType.FloatingPointRoundingModeType;
} else if (msat_is_array_type(env, type)) {
long indexType = msat_get_array_index_type(env, type);
long elementType = msat_get_array_element_type(env, type);
return FormulaType.getArrayType(
getFormulaTypeFromTermType(indexType), getFormulaTypeFromTermType(elementType));
} else if (msat_is_enum_type(env, type)) {
String enumName = msat_type_repr(type);
ImmutableSet.Builder<String> elements = ImmutableSet.builder();
for (long constantDecl : msat_get_enum_constants(env, type)) {
elements.add(msat_decl_get_name(constantDecl));
}
return FormulaType.getEnumerationType(enumName, elements.build());
} else {
throw new IllegalArgumentException("Unknown formula type " + msat_type_repr(type));
}
}
@Override
public Long getBitvectorType(int pBitwidth) {
return msat_get_bv_type(getEnv(), pBitwidth);
}
@Override
public Long getFloatingPointType(FloatingPointType pType) {
return msat_get_fp_type(getEnv(), pType.getExponentSize(), pType.getMantissaSize());
}
@SuppressWarnings("unchecked")
@Override
public <T extends Formula> T encapsulate(FormulaType<T> pType, Long pTerm) {
assert pType.equals(getFormulaType(pTerm))
|| (pType.equals(FormulaType.RationalType)
&& getFormulaType(pTerm).equals(FormulaType.IntegerType))
: String.format(
"Trying to encapsulate formula of type %s as %s", getFormulaType(pTerm), pType);
if (pType.isBooleanType()) {
return (T) new Mathsat5BooleanFormula(pTerm);
} else if (pType.isIntegerType()) {
return (T) new Mathsat5IntegerFormula(pTerm);
} else if (pType.isRationalType()) {
return (T) new Mathsat5RationalFormula(pTerm);
} else if (pType.isArrayType()) {
ArrayFormulaType<?, ?> arrFt = (ArrayFormulaType<?, ?>) pType;
return (T) new Mathsat5ArrayFormula<>(pTerm, arrFt.getIndexType(), arrFt.getElementType());
} else if (pType.isBitvectorType()) {
return (T) new Mathsat5BitvectorFormula(pTerm);
} else if (pType.isFloatingPointType()) {
return (T) new Mathsat5FloatingPointFormula(pTerm);
} else if (pType.isFloatingPointRoundingModeType()) {
return (T) new Mathsat5FloatingPointRoundingModeFormula(pTerm);
} else if (pType.isEnumerationType()) {
return (T) new Mathsat5EnumerationFormula(pTerm);
}
throw new IllegalArgumentException("Cannot create formulas of type " + pType + " in MathSAT");
}
@Override
public BooleanFormula encapsulateBoolean(Long pTerm) {
assert getFormulaType(pTerm).isBooleanType();
return new Mathsat5BooleanFormula(pTerm);
}
@Override
public BitvectorFormula encapsulateBitvector(Long pTerm) {
assert getFormulaType(pTerm).isBitvectorType();
return new Mathsat5BitvectorFormula(pTerm);
}
@Override
protected FloatingPointFormula encapsulateFloatingPoint(Long pTerm) {
assert getFormulaType(pTerm).isFloatingPointType();
return new Mathsat5FloatingPointFormula(pTerm);
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TI extends Formula, TE extends Formula> ArrayFormula<TI, TE> encapsulateArray(
Long pTerm, FormulaType<TI> pIndexType, FormulaType<TE> pElementType) {
assert getFormulaType(pTerm).equals(FormulaType.getArrayType(pIndexType, pElementType));
return new Mathsat5ArrayFormula<>(pTerm, pIndexType, pElementType);
}
@Override
protected EnumerationFormula encapsulateEnumeration(Long pTerm) {
assert getFormulaType(pTerm).isEnumerationType();
return new Mathsat5EnumerationFormula(pTerm);
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TI extends Formula, TE extends Formula> FormulaType<TE> getArrayFormulaElementType(
ArrayFormula<TI, TE> pArray) {
return ((Mathsat5ArrayFormula<TI, TE>) pArray).getElementType();
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TI extends Formula, TE extends Formula> FormulaType<TI> getArrayFormulaIndexType(
ArrayFormula<TI, TE> pArray) {
return ((Mathsat5ArrayFormula<TI, TE>) pArray).getIndexType();
}
@Override
public Long getArrayType(Long pIndexType, Long pElementType) {
return msat_get_array_type(getEnv(), pIndexType, pElementType);
}
@Override
public <R> R visit(FormulaVisitor<R> visitor, Formula formula, final Long f) {
int arity = msat_term_arity(f);
if (msat_term_is_number(environment, f)) {
return visitor.visitConstant(formula, convertValue(f, f));
} else if (msat_term_is_true(environment, f)) {
return visitor.visitConstant(formula, true);
} else if (msat_term_is_false(environment, f)) {
return visitor.visitConstant(formula, false);
} else if (msat_term_is_constant(environment, f)) {
return visitor.visitFreeVariable(formula, msat_term_repr(f));
} else if (msat_is_enum_type(environment, msat_term_get_type(f))) {
assert !msat_term_is_constant(environment, f) : "Enumeration constants are no variables";
assert arity == 0 : "Enumeration constants have no parameters";
return visitor.visitConstant(formula, msat_term_repr(f));
} else {
final long declaration = msat_term_get_decl(f);
final String name = msat_decl_get_name(declaration);
if (arity == 0 && name.startsWith("'")) {
// symbols starting with "'" are missed as constants, but seen as functions of type OTHER
return visitor.visitFreeVariable(formula, name);
}
ImmutableList.Builder<Formula> args = ImmutableList.builder();
ImmutableList.Builder<FormulaType<?>> argTypes = ImmutableList.builder();
for (int i = 0; i < arity; i++) {
// argumentType can be sub-type of parameterType, e.g., int < rational
long arg = msat_term_get_arg(f, i);
FormulaType<?> argumentType = getFormulaType(arg);
args.add(encapsulate(argumentType, arg));
long argType = msat_decl_get_arg_type(declaration, i);
FormulaType<?> parameterType = getFormulaTypeFromTermType(argType);
argTypes.add(parameterType);
}
return visitor.visitFunction(
formula,
args.build(),
FunctionDeclarationImpl.of(
name,
getDeclarationKind(f),
argTypes.build(),
getFormulaType(f),
msat_term_get_decl(f)));
}
}
String getName(long term) {
if (msat_term_is_uf(environment, term)) {
return msat_decl_get_name(msat_term_get_decl(term));
}
return msat_term_repr(term);
}
private FunctionDeclarationKind getDeclarationKind(long pF) {
if (msat_term_is_uf(environment, pF)) {
return FunctionDeclarationKind.UF;
}
assert !msat_term_is_constant(environment, pF) : "Variables should be handled somewhere else";
long decl = msat_term_get_decl(pF);
int tag = msat_decl_get_tag(environment, decl);
switch (tag) {
case MSAT_TAG_AND:
return FunctionDeclarationKind.AND;
case MSAT_TAG_NOT:
return FunctionDeclarationKind.NOT;
case MSAT_TAG_OR:
return FunctionDeclarationKind.OR;
case MSAT_TAG_IFF:
return FunctionDeclarationKind.IFF;
case MSAT_TAG_ITE:
return FunctionDeclarationKind.ITE;
case MSAT_TAG_TIMES:
return FunctionDeclarationKind.MUL;
case MSAT_TAG_PLUS:
return FunctionDeclarationKind.ADD;
case MSAT_TAG_LEQ:
return FunctionDeclarationKind.LTE;
case MSAT_TAG_EQ:
return FunctionDeclarationKind.EQ;
case MSAT_TAG_ARRAY_READ:
return FunctionDeclarationKind.SELECT;
case MSAT_TAG_ARRAY_WRITE:
return FunctionDeclarationKind.STORE;
case MSAT_TAG_BV_EXTRACT:
return FunctionDeclarationKind.BV_EXTRACT;
case MSAT_TAG_BV_CONCAT:
return FunctionDeclarationKind.BV_CONCAT;
case MSAT_TAG_BV_NOT:
return FunctionDeclarationKind.BV_NOT;
case MSAT_TAG_BV_NEG:
return FunctionDeclarationKind.BV_NEG;
case MSAT_TAG_BV_AND:
return FunctionDeclarationKind.BV_AND;
case MSAT_TAG_BV_OR:
return FunctionDeclarationKind.BV_OR;
case MSAT_TAG_BV_XOR:
return FunctionDeclarationKind.BV_XOR;
case MSAT_TAG_BV_ULT:
return FunctionDeclarationKind.BV_ULT;
case MSAT_TAG_BV_SLT:
return FunctionDeclarationKind.BV_SLT;
case MSAT_TAG_BV_ULE:
return FunctionDeclarationKind.BV_ULE;
case MSAT_TAG_BV_SLE:
return FunctionDeclarationKind.BV_SLE;
case MSAT_TAG_BV_ADD:
return FunctionDeclarationKind.BV_ADD;
case MSAT_TAG_BV_SUB:
return FunctionDeclarationKind.BV_SUB;
case MSAT_TAG_BV_MUL:
return FunctionDeclarationKind.BV_MUL;
case MSAT_TAG_BV_UDIV:
return FunctionDeclarationKind.BV_UDIV;
case MSAT_TAG_BV_SDIV:
return FunctionDeclarationKind.BV_SDIV;
case MSAT_TAG_BV_UREM:
return FunctionDeclarationKind.BV_UREM;
case MSAT_TAG_BV_SREM:
return FunctionDeclarationKind.BV_SREM;
case MSAT_TAG_BV_LSHL:
return FunctionDeclarationKind.BV_SHL;
case MSAT_TAG_BV_LSHR:
return FunctionDeclarationKind.BV_LSHR;
case MSAT_TAG_BV_ASHR:
return FunctionDeclarationKind.BV_ASHR;
case MSAT_TAG_BV_SEXT:
return FunctionDeclarationKind.BV_SIGN_EXTENSION;
case MSAT_TAG_BV_ZEXT:
return FunctionDeclarationKind.BV_ZERO_EXTENSION;
case MSAT_TAG_FP_NEG:
return FunctionDeclarationKind.FP_NEG;
case MSAT_TAG_FP_ABS:
return FunctionDeclarationKind.FP_ABS;
case MSAT_TAG_FP_MAX:
return FunctionDeclarationKind.FP_MAX;
case MSAT_TAG_FP_MIN:
return FunctionDeclarationKind.FP_MIN;
case MSAT_TAG_FP_SQRT:
return FunctionDeclarationKind.FP_SQRT;
case MSAT_TAG_FP_ADD:
return FunctionDeclarationKind.FP_ADD;
case MSAT_TAG_FP_SUB:
return FunctionDeclarationKind.FP_SUB;
case MSAT_TAG_FP_DIV:
return FunctionDeclarationKind.FP_DIV;
case MSAT_TAG_FP_MUL:
return FunctionDeclarationKind.FP_MUL;
case MSAT_TAG_FP_LT:
return FunctionDeclarationKind.FP_LT;
case MSAT_TAG_FP_LE:
return FunctionDeclarationKind.FP_LE;
case MSAT_TAG_FP_EQ:
return FunctionDeclarationKind.FP_EQ;
case MSAT_TAG_FP_ROUND_TO_INT:
return FunctionDeclarationKind.FP_ROUND_TO_INTEGRAL;
case MSAT_TAG_FP_FROM_SBV:
return FunctionDeclarationKind.BV_SCASTTO_FP;
case MSAT_TAG_FP_FROM_UBV:
return FunctionDeclarationKind.BV_UCASTTO_FP;
case MSAT_TAG_FP_TO_SBV:
return FunctionDeclarationKind.FP_CASTTO_SBV;
case MSAT_TAG_FP_TO_UBV:
return FunctionDeclarationKind.FP_CASTTO_UBV;
case MSAT_TAG_FP_AS_IEEEBV:
return FunctionDeclarationKind.FP_AS_IEEEBV;
case MSAT_TAG_FP_CAST:
return FunctionDeclarationKind.FP_CASTTO_FP;
case MSAT_TAG_FP_ISNAN:
return FunctionDeclarationKind.FP_IS_NAN;
case MSAT_TAG_FP_ISINF:
return FunctionDeclarationKind.FP_IS_INF;
case MSAT_TAG_FP_ISZERO:
return FunctionDeclarationKind.FP_IS_ZERO;
case MSAT_TAG_FP_ISNEG:
return FunctionDeclarationKind.FP_IS_NEGATIVE;
case MSAT_TAG_FP_ISSUBNORMAL:
return FunctionDeclarationKind.FP_IS_SUBNORMAL;
case MSAT_TAG_FP_ISNORMAL:
return FunctionDeclarationKind.FP_IS_NORMAL;
case MSAT_TAG_UNKNOWN:
switch (msat_decl_get_name(decl)) {
case "`fprounding_even`":
return FunctionDeclarationKind.FP_ROUND_EVEN;
case "`fprounding_plus_inf`":
return FunctionDeclarationKind.FP_ROUND_POSITIVE;
case "`fprounding_minus_inf`":
return FunctionDeclarationKind.FP_ROUND_NEGATIVE;
case "`fprounding_zero`":
return FunctionDeclarationKind.FP_ROUND_ZERO;
default:
return FunctionDeclarationKind.OTHER;
}
case MSAT_TAG_FLOOR:
return FunctionDeclarationKind.FLOOR;
default:
return FunctionDeclarationKind.OTHER;
}
}
@Override
public Object convertValue(Long key, Long term) {
// To get the correct type, we generate it from the key, not the value.
FormulaType<?> type = getFormulaType(key);
String repr = msat_term_repr(term);
if (type.isBooleanType()) {
return msat_term_is_true(getEnv(), term);
} else if (type.isRationalType()) {
Rational ratValue = Rational.ofString(repr);
return ratValue.isIntegral() ? ratValue.getNum() : ratValue;
} else if (type.isIntegerType()) {
return new BigInteger(repr);
} else if (type.isBitvectorType()) {
return parseBitvector(repr);
} else if (type.isFloatingPointType()) {
return parseFloatingPoint(repr);
} else if (type.isEnumerationType()) {
return repr;
} else {
throw new IllegalArgumentException("Unexpected type: " + type);
}
}
private Number parseFloatingPoint(String lTermRepresentation) {
// the term is of the format "<VALUE>_<EXPWIDTH>_<MANTWIDTH>"
Matcher matcher = FLOATING_POINT_PATTERN.matcher(lTermRepresentation);
if (!matcher.matches()) {
throw new NumberFormatException("Unknown floating-point format: " + lTermRepresentation);
}
int expWidth = Integer.parseInt(matcher.group(2));
int mantWidth = Integer.parseInt(matcher.group(3));
if (expWidth == 11 && mantWidth == 52) {
return Double.longBitsToDouble(UnsignedLong.valueOf(matcher.group(1)).longValue());
} else if (expWidth == 8 && mantWidth == 23) {
return Float.intBitsToFloat(UnsignedInteger.valueOf(matcher.group(1)).intValue());
}
// TODO to be fully correct, we would need to interpret this string
return new BigInteger(matcher.group(1));
}
// TODO: change this to the latest version
// (if possible try to use a BitvectorFormula instance here)
private static BigInteger parseBitvector(String lTermRepresentation) {
// the term is of the format "<VALUE>_<WIDTH>"
Matcher matcher = BITVECTOR_PATTERN.matcher(lTermRepresentation);
if (!matcher.matches()) {
throw new NumberFormatException("Unknown bitvector format: " + lTermRepresentation);
}
// TODO: calculate negative value?
String term = matcher.group(1);
return new BigInteger(term);
}
@Override
public Long declareUFImpl(String pName, Long returnType, List<Long> pArgTypes) {
long[] types = Longs.toArray(pArgTypes);
final long msatFuncType;
if (pArgTypes.isEmpty()) {
// a nullary function is a plain symbol (variable)
msatFuncType = returnType;
} else {
msatFuncType = msat_get_function_type(environment, types, types.length, returnType);
}
long decl = msat_declare_function(environment, pName, msatFuncType);
return decl;
}
@Override
public Long callFunctionImpl(Long declaration, List<Long> args) {
return msat_make_term(environment, declaration, Longs.toArray(args));
}
@Override
protected Long getBooleanVarDeclarationImpl(Long pLong) {
return msat_term_get_decl(pLong);
}
}
| 29,134 | 46.220421 | 103 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5FormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_apply_substitution;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_from_smtlib2;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_copy_from;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_simplify;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_to_smtlib2;
import com.google.common.base.Splitter;
import com.google.common.collect.Collections2;
import com.google.common.primitives.Longs;
import java.io.IOException;
import java.util.Collection;
import java.util.Map;
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.api.FormulaManager;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.basicimpl.AbstractFormulaManager;
final class Mathsat5FormulaManager extends AbstractFormulaManager<Long, Long, Long, Long> {
@SuppressWarnings("checkstyle:parameternumber")
Mathsat5FormulaManager(
Mathsat5FormulaCreator creator,
Mathsat5UFManager pFunctionManager,
Mathsat5BooleanFormulaManager pBooleanManager,
Mathsat5IntegerFormulaManager pIntegerManager,
Mathsat5RationalFormulaManager pRationalManager,
Mathsat5BitvectorFormulaManager pBitpreciseManager,
Mathsat5FloatingPointFormulaManager pFloatingPointManager,
Mathsat5ArrayFormulaManager pArrayManager,
Mathsat5EnumerationFormulaManager pEnumerationManager) {
super(
creator,
pFunctionManager,
pBooleanManager,
pIntegerManager,
pRationalManager,
pBitpreciseManager,
pFloatingPointManager,
null,
pArrayManager,
null,
null,
pEnumerationManager);
}
static long getMsatTerm(Formula pT) {
return ((Mathsat5Formula) pT).getTerm();
}
static long[] getMsatTerm(Collection<? extends Formula> pFormulas) {
return Longs.toArray(Collections2.transform(pFormulas, Mathsat5FormulaManager::getMsatTerm));
}
@Override
public BooleanFormula parse(String pS) throws IllegalArgumentException {
long f = msat_from_smtlib2(getEnvironment(), pS);
return getFormulaCreator().encapsulateBoolean(f);
}
@Override
public Appender dumpFormula(final Long f) {
assert getFormulaCreator().getFormulaType(f) == FormulaType.BooleanType
: "Only BooleanFormulas may be dumped";
// Lazy invocation of msat_to_smtlib2 wrapped in an Appender.
return new Appenders.AbstractAppender() {
@Override
public void appendTo(Appendable out) throws IOException {
String msatString = msat_to_smtlib2(getEnvironment(), f);
// Adjust line breaks: assert needs to be on last line, so we remove all following breaks.
boolean needsLinebreak = true;
for (String part : Splitter.on('\n').split(msatString)) {
out.append(part);
if (needsLinebreak && part.startsWith("(assert")) {
needsLinebreak = false;
}
if (needsLinebreak) {
out.append('\n');
}
}
}
};
}
@Override
public <T extends Formula> T substitute(
final T f, final Map<? extends Formula, ? extends Formula> fromToMapping) {
long[] changeFrom = new long[fromToMapping.size()];
long[] changeTo = new long[fromToMapping.size()];
int idx = 0;
for (Map.Entry<? extends Formula, ? extends Formula> e : fromToMapping.entrySet()) {
changeFrom[idx] = extractInfo(e.getKey());
changeTo[idx] = extractInfo(e.getValue());
idx++;
}
FormulaType<T> type = getFormulaType(f);
return getFormulaCreator()
.encapsulate(
type,
msat_apply_substitution(
getFormulaCreator().getEnv(),
extractInfo(f),
fromToMapping.size(),
changeFrom,
changeTo));
}
@Override
protected Long simplify(Long f) throws InterruptedException {
// we need to keep all variables, otherwise we will not return a equisatisfiable formula.
// TODO we could expand the interface and let the user choose the variables.
final Map<String, Long> variables = getFormulaCreator().extractVariablesAndUFs(f, true);
final long[] protectedSymbols = Longs.toArray(variables.values());
return msat_simplify(getFormulaCreator().getEnv(), f, protectedSymbols);
}
@Override
public BooleanFormula translateFrom(BooleanFormula formula, FormulaManager otherManager) {
if (otherManager instanceof Mathsat5FormulaManager) {
long otherMsatContext = ((Mathsat5FormulaManager) otherManager).getEnvironment();
if (otherMsatContext == getEnvironment()) {
// Same context.
return formula;
} else {
// Msat5 to Msat5 translation.
long translatedFormula =
msat_make_copy_from(getEnvironment(), extractInfo(formula), otherMsatContext);
return getFormulaCreator().encapsulateBoolean(translatedFormula);
}
}
return super.translateFrom(formula, otherManager);
}
}
| 5,537 | 36.167785 | 98 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5IntegerFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_divide;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_floor;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_int_modular_congruence;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_int_number;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_leq;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_number;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_term_ite;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_times;
import java.math.BigDecimal;
import java.math.BigInteger;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
class Mathsat5IntegerFormulaManager
extends Mathsat5NumeralFormulaManager<IntegerFormula, IntegerFormula>
implements IntegerFormulaManager {
Mathsat5IntegerFormulaManager(
Mathsat5FormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
}
@Override
protected long getNumeralType() {
return getFormulaCreator().getIntegerType();
}
@Override
protected Long makeNumberImpl(double pNumber) {
return makeNumberImpl((long) pNumber);
}
@Override
protected Long makeNumberImpl(BigDecimal pNumber) {
return decimalAsInteger(pNumber);
}
private long ceil(long t) {
final long minusOne = msat_make_number(mathsatEnv, "-1");
return msat_make_times(
mathsatEnv,
msat_make_floor(mathsatEnv, msat_make_times(mathsatEnv, t, minusOne)),
minusOne);
}
@Override
public Long divide(Long pNumber1, Long pNumber2) {
// Follow SMTLib rounding definition (http://smtlib.cs.uiowa.edu/theories-Ints.shtml):
// (t2 <= 0) ? ceil(t1/t2) : floor(t1/t2)
// (t2 <= 0) ? -floor(-(t1/t2)) : floor(t1/2)
// According to Alberto Griggio, it is not worth hand-optimizing this,
// MathSAT will simplify this to something like floor(1/t2 * t1) for linear queries anyway.
final long div = msat_make_divide(mathsatEnv, pNumber1, pNumber2);
return msat_make_term_ite(
mathsatEnv,
msat_make_leq(mathsatEnv, pNumber2, msat_make_int_number(mathsatEnv, 0)),
ceil(div),
msat_make_floor(mathsatEnv, div));
}
@Override
protected Long modularCongruence(Long pNumber1, Long pNumber2, BigInteger pModulo) {
return modularCongruence0(pNumber1, pNumber2, pModulo.toString());
}
@Override
protected Long modularCongruence(Long pNumber1, Long pNumber2, long pModulo) {
return modularCongruence0(pNumber1, pNumber2, Long.toString(pModulo));
}
protected Long modularCongruence0(Long pNumber1, Long pNumber2, String pModulo) {
return msat_make_int_modular_congruence(mathsatEnv, pModulo, pNumber1, pNumber2);
}
}
| 3,294 | 37.313953 | 104 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5InterpolatingProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_assert_formula;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_create_itp_group;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_interpolant;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_push_backtrack_point;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_set_itp_group;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.primitives.Ints;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
class Mathsat5InterpolatingProver extends Mathsat5AbstractProver<Integer>
implements InterpolatingProverEnvironment<Integer> {
private static final ImmutableSet<String> ALLOWED_FAILURE_MESSAGES =
ImmutableSet.of(
"Unexpected proof rule to split: PN4msat5proof5ProofE",
"impossible to build a suitable congruence graph!",
"can't build ie-local interpolant",
"set_raised on an already-raised proof",
"splitting of AB-mixed terms not supported",
"Hypothesis belongs neither to A nor to B",
"FP<->BV combination unsupported by the current configuration",
"cur_eq unknown to the classifier",
"unknown constraint in the ItpMapper",
"AB-mixed term not found in eq_itp map",
"uncolored atom found in Array proof",
"uncolorable Array proof",
"arr: proof splitting not supported",
"AB-mixed term in LaHyp",
"AB-mixed term in LaCombImp");
private static final ImmutableSet<String> ALLOWED_FAILURE_MESSAGE_PREFIXES =
ImmutableSet.of("uncolorable NA lemma");
Mathsat5InterpolatingProver(
Mathsat5SolverContext pMgr,
ShutdownNotifier pShutdownNotifier,
Mathsat5FormulaCreator creator,
Set<ProverOptions> options) {
super(pMgr, options, creator, pShutdownNotifier);
}
@Override
protected void createConfig(Map<String, String> pConfig) {
pConfig.put("interpolation", "true");
pConfig.put("model_generation", "true");
pConfig.put("theory.bv.eager", "false");
}
@Override
public Integer addConstraint(BooleanFormula f) {
Preconditions.checkState(!closed);
closeAllEvaluators();
int group = msat_create_itp_group(curEnv);
msat_set_itp_group(curEnv, group);
long t = creator.extractInfo(f);
msat_assert_formula(curEnv, t);
return group;
}
@Override
public void push() {
Preconditions.checkState(!closed);
msat_push_backtrack_point(curEnv);
}
@Override
protected long getMsatModel() throws SolverException {
// Interpolation in MathSAT is buggy at least for UFs+Ints and sometimes returns a wrong "SAT".
// In this case, model generation fails and users should try again without interpolation.
// Example failures: "Invalid model", "non-integer model value"
// As this is a bug in MathSAT and not in our code, we throw a SolverException.
// We do it only in InterpolatingProver because without interpolation this is not expected.
try {
return super.getMsatModel();
} catch (IllegalArgumentException e) {
String msg = Strings.emptyToNull(e.getMessage());
throw new SolverException(
"msat_get_model failed"
+ (msg != null ? " with \"" + msg + "\"" : "")
+ ", probably the actual problem is interpolation",
e);
}
}
@Override
public BooleanFormula getInterpolant(Collection<Integer> formulasOfA) throws SolverException {
Preconditions.checkState(!closed);
int[] groupsOfA = Ints.toArray(formulasOfA);
long itp;
try {
itp = msat_get_interpolant(curEnv, groupsOfA);
} catch (IllegalArgumentException e) {
final String message = e.getMessage();
if (!Strings.isNullOrEmpty(message)
&& (ALLOWED_FAILURE_MESSAGES.contains(message)
|| ALLOWED_FAILURE_MESSAGE_PREFIXES.stream().anyMatch(message::startsWith))) {
// This is not a bug in our code,
// but a problem of MathSAT which happens during interpolation
throw new SolverException(message, e);
}
throw e;
}
return creator.encapsulateBoolean(itp);
}
@Override
public List<BooleanFormula> getSeqInterpolants(
List<? extends Collection<Integer>> partitionedFormulas) throws SolverException {
Preconditions.checkArgument(
!partitionedFormulas.isEmpty(), "at least one partition should be available.");
// the fallback to a loop is sound and returns an inductive sequence of interpolants
final List<BooleanFormula> itps = new ArrayList<>();
for (int i = 1; i < partitionedFormulas.size(); i++) {
itps.add(
getInterpolant(
ImmutableList.copyOf(Iterables.concat(partitionedFormulas.subList(0, i)))));
}
return itps;
}
@Override
public List<BooleanFormula> getTreeInterpolants(
List<? extends Collection<Integer>> partitionedFormulas, int[] startOfSubTree) {
throw new UnsupportedOperationException(
"directly receiving tree interpolants is not supported."
+ "Use another solver or another strategy for interpolants.");
}
@Override
public <T> T allSat(AllSatCallback<T> callback, List<BooleanFormula> important) {
// TODO how can we support allsat in MathSat5-interpolation-prover?
// error: "allsat is not compatible wwith proof generation"
throw new UnsupportedOperationException(
"allsat computation is not possible with interpolation prover.");
}
}
| 6,417 | 38.617284 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5Model.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_destroy_model;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_destroy_model_iterator;
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_make_array_read;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_eq;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_model_create_iterator;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_model_eval;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_model_iterator_has_next;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_model_iterator_next;
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_type;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_is_array_write;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Set;
import org.sosy_lab.java_smt.basicimpl.AbstractModel;
class Mathsat5Model extends AbstractModel<Long, Long, Long> {
private final long model;
private final Mathsat5FormulaCreator formulaCreator;
/** for detecting closed environments, Exception is better than SegFault. */
private final Mathsat5AbstractProver<?> prover;
Mathsat5Model(long model, Mathsat5FormulaCreator creator, Mathsat5AbstractProver<?> pProver) {
super(pProver, creator);
this.model = model;
formulaCreator = creator;
prover = pProver;
}
@Override
public ImmutableList<ValueAssignment> asList() {
Preconditions.checkState(!isClosed());
Preconditions.checkState(!prover.closed, "cannot use model after prover is closed");
ImmutableList.Builder<ValueAssignment> assignments = ImmutableList.builder();
long modelIterator = msat_model_create_iterator(model);
while (msat_model_iterator_has_next(modelIterator)) {
long[] key = new long[1];
long[] value = new long[1];
if (msat_model_iterator_next(modelIterator, key, value)) {
throw new NoSuchElementException();
}
if (msat_is_array_type(creator.getEnv(), msat_term_get_type(value[0]))) {
assignments.addAll(getArrayAssignments(key[0], key[0], value[0], ImmutableList.of()));
} else {
assignments.add(getAssignment(key[0], value[0]));
}
}
msat_destroy_model_iterator(modelIterator);
return assignments.build();
}
private ValueAssignment getAssignment(long key, long value) {
List<Object> argumentInterpretation = new ArrayList<>();
for (int i = 0; i < msat_term_arity(key); i++) {
long arg = msat_term_get_arg(key, i);
argumentInterpretation.add(evaluateImpl(arg));
}
return new ValueAssignment(
creator.encapsulateWithTypeOf(key),
creator.encapsulateWithTypeOf(value),
creator.encapsulateBoolean(msat_make_eq(creator.getEnv(), key, value)),
formulaCreator.getName(key),
formulaCreator.convertValue(key, value),
argumentInterpretation);
}
/** split an array-assignment into several assignments for all positions. */
private Collection<ValueAssignment> getArrayAssignments(
long symbol, long key, long array, List<Object> upperIndices) {
Collection<ValueAssignment> assignments = new ArrayList<>();
Set<Long> indices = new HashSet<>();
while (msat_term_is_array_write(creator.getEnv(), array)) {
long index = msat_term_get_arg(array, 1);
long content = msat_term_get_arg(array, 2);
array = msat_term_get_arg(array, 0);
if (!indices.add(index)) {
// sometimes MathSat5 provides a model-assignment like
// "ARR := (write (write (write (const 0) 5 1) 0 0) 5 2)",
// where the index "5" is assigned twice, even with different values.
// In this case we skip the second (deeper nested) assignment.
// In this example we ignore the assignment "ARR[5] := 1".
continue;
}
List<Object> innerIndices = new ArrayList<>(upperIndices);
innerIndices.add(evaluateImpl(index));
long select = msat_make_array_read(creator.getEnv(), key, index);
if (msat_is_array_type(creator.getEnv(), msat_term_get_type(content))) {
assignments.addAll(getArrayAssignments(symbol, select, content, innerIndices));
} else {
assignments.add(
new ValueAssignment(
creator.encapsulateWithTypeOf(select),
creator.encapsulateWithTypeOf(content),
creator.encapsulateBoolean(msat_make_eq(creator.getEnv(), select, content)),
formulaCreator.getName(symbol),
evaluateImpl(content),
innerIndices));
}
}
return assignments;
}
@Override
public void close() {
if (!isClosed()) {
msat_destroy_model(model);
}
super.close();
}
@Override
protected Long evalImpl(Long formula) {
Preconditions.checkState(!isClosed());
Preconditions.checkState(!prover.closed, "cannot use model after prover is closed");
return msat_model_eval(model, formula);
}
}
| 5,909 | 40.328671 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5NativeApi.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
/*
* This file was automatically generated by extract_java_stub.py
* Wrapper for the MathSAT API for Java
*/
package org.sosy_lab.java_smt.solvers.mathsat5;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableSet;
import com.google.errorprone.annotations.CheckReturnValue;
import org.sosy_lab.java_smt.api.SolverException;
@SuppressWarnings({"unused", "checkstyle:methodname", "checkstyle:parametername"})
class Mathsat5NativeApi {
private Mathsat5NativeApi() {}
// msat_result
private static final int MSAT_UNKNOWN = -1;
private static final int MSAT_UNSAT = 0;
private static final int MSAT_SAT = 1;
// msat_truth_value
public static final int MSAT_UNDEF = -1;
public static final int MSAT_FALSE = 0;
public static final int MSAT_TRUE = 1;
/** OptiMathSAT codes for queries on objective items. */
public static final int MSAT_OPTIMUM = 0;
public static final int MSAT_FINAL_LOWER = 1;
public static final int MSAT_FINAL_UPPER = 2;
public static final int MSAT_FINAL_ERROR = 3;
/** OptiMathSAT objective type, either minimize or maximize. */
public static final int MSAT_OBJECTIVE_MINIMIZE = -1;
public static final int MSAT_OBJECTIVE_MAXIMIZE = 1;
/** MathSAT tags. */
public static final int MSAT_TAG_ERROR = -1;
public static final int MSAT_TAG_UNKNOWN = 0;
public static final int MSAT_TAG_TRUE = 1; // < the Boolean constant True
public static final int MSAT_TAG_FALSE = 2; // < the Boolean constant False
public static final int MSAT_TAG_AND = 3; // < the AND Boolean connective
public static final int MSAT_TAG_OR = 4; // < the OR Boolean connective
public static final int MSAT_TAG_NOT = 5; // < the NOT Boolean connective
public static final int MSAT_TAG_IFF = 6; // < the IFF Boolean connective
public static final int MSAT_TAG_PLUS = 7; // < arithmetic addition
public static final int MSAT_TAG_TIMES = 8; // < arithmetic multiplication
public static final int MSAT_TAG_DIVIDE = 9; // < arithmetic multiplication
public static final int MSAT_TAG_FLOOR = 10; // < floor function
public static final int MSAT_TAG_LEQ = 11; // < arithmetic <=
public static final int MSAT_TAG_EQ = 12; // < equality
public static final int MSAT_TAG_ITE = 13; // < term-level if-then-else
public static final int MSAT_TAG_INT_MOD_CONGR = 14; // < integer modular congruence
public static final int MSAT_TAG_BV_CONCAT = 15; // < BV concatenation
public static final int MSAT_TAG_BV_EXTRACT = 16; // < BV selection
public static final int MSAT_TAG_BV_NOT = 17; // < BV bitwise not
public static final int MSAT_TAG_BV_AND = 18; // < BV bitwise and
public static final int MSAT_TAG_BV_OR = 19; // < BV bitwise or
public static final int MSAT_TAG_BV_XOR = 20; // < BV bitwise xor
public static final int MSAT_TAG_BV_ULT = 21; // < BV unsigned <
public static final int MSAT_TAG_BV_SLT = 22; // < BV signed <
public static final int MSAT_TAG_BV_ULE = 23; // < BV unsigned <=
public static final int MSAT_TAG_BV_SLE = 24; // < BV signed <
public static final int MSAT_TAG_BV_COMP = 25; // < BV bit comparison
public static final int MSAT_TAG_BV_NEG = 26; // < BV unary minus
public static final int MSAT_TAG_BV_ADD = 27; // < BV addition
public static final int MSAT_TAG_BV_SUB = 28; // < BV subtraction
public static final int MSAT_TAG_BV_MUL = 29; // < BV multiplication
public static final int MSAT_TAG_BV_UDIV = 30; // < BV unsigned division
public static final int MSAT_TAG_BV_SDIV = 31; // < BV signed division
public static final int MSAT_TAG_BV_UREM = 32; // < BV unsigned remainder
public static final int MSAT_TAG_BV_SREM = 33; // < BV signed remainder
public static final int MSAT_TAG_BV_LSHL = 34; // < BV logical left shift
public static final int MSAT_TAG_BV_LSHR = 35; // < BV logical right shift
public static final int MSAT_TAG_BV_ASHR = 36; // < BV arithmetic right shift
public static final int MSAT_TAG_BV_ROL = 37; // < BV rotate left
public static final int MSAT_TAG_BV_ROR = 38; // < BV rotate right
public static final int MSAT_TAG_BV_ZEXT = 39; // < BV zero extension
public static final int MSAT_TAG_BV_SEXT = 40; // < BV sign extension
public static final int MSAT_TAG_ARRAY_READ = 41; // < Array read/select operation
public static final int MSAT_TAG_ARRAY_WRITE = 42; // < Array write/store operation
public static final int MSAT_TAG_ARRAY_CONST = 43; // < Constant arrays
public static final int MSAT_TAG_FP_EQ = 44; // < FP IEEE equality
public static final int MSAT_TAG_FP_LT = 45; // < FP <
public static final int MSAT_TAG_FP_LE = 46; // < FP <=
public static final int MSAT_TAG_FP_NEG = 47; // < FP unary minus
public static final int MSAT_TAG_FP_ADD = 48; // < FP addition
public static final int MSAT_TAG_FP_SUB = 49; // < FP subtraction
public static final int MSAT_TAG_FP_MUL = 50; // < FP multiplication
public static final int MSAT_TAG_FP_DIV = 51; // < FP division
public static final int MSAT_TAG_FP_SQRT = 52; // < FP square root
public static final int MSAT_TAG_FP_ABS = 53; // < FP absolute value
public static final int MSAT_TAG_FP_MIN = 54; // < FP min
public static final int MSAT_TAG_FP_MAX = 55; // < FP max
public static final int MSAT_TAG_FP_CAST = 56; // < FP format conversion
public static final int MSAT_TAG_FP_ROUND_TO_INT = 57; // < FP round to integer
public static final int MSAT_TAG_FP_FROM_SBV = 58; // < FP conversion from a signed BV
public static final int MSAT_TAG_FP_FROM_UBV = 59; // < FP conversion from an unsigned BV
public static final int MSAT_TAG_FP_TO_SBV = 60; // < FP conversion to BV
public static final int MSAT_TAG_FP_TO_UBV = 61; // < FP conversion to BV
public static final int MSAT_TAG_FP_AS_IEEEBV = 62; // < FP as IEEE BV (access to the bits)
public static final int MSAT_TAG_FP_ISNAN = 63; // < FP check for NaN
public static final int MSAT_TAG_FP_ISINF = 64; // < FP check for infinity
public static final int MSAT_TAG_FP_ISZERO = 65; // < FP check for zero
public static final int MSAT_TAG_FP_ISSUBNORMAL = 66; // < FP check for subnormal
public static final int MSAT_TAG_FP_ISNORMAL = 67; // < FP check for normal
public static final int MSAT_TAG_FP_ISNEG = 68; // < FP check for negative
public static final int MSAT_TAG_FP_ISPOS = 69; // < FP check for positive
public static final int MSAT_TAG_FP_FROM_IEEEBV = 70; // < FP conversion from IEEE BV
public static final int MSAT_TAG_INT_FROM_UBV = 71; // < Unsigned BV -> INT conversion
public static final int MSAT_TAG_INT_FROM_SBV = 72; // < Signed BV -> INT conversion
public static final int MSAT_TAG_INT_TO_BV = 73; // < INT -> BV conversion
public static final int MSAT_TAG_PI = 74; // Pi constant
public static final int MSAT_TAG_EXP = 75; // Exponential function
public static final int MSAT_TAG_SIN = 76; // Sine function
public static final int MSAT_TAG_LOG = 77; // Natural logarithm function
public static final int MSAT_TAG_POW = 78;
public static final int MSAT_TAG_ASIN = 79;
public static final int MSAT_TAG_FORALL = 80;
public static final int MSAT_TAG_EXISTS = 81;
interface AllSatModelCallback {
void callback(long[] model) throws InterruptedException;
}
interface TerminationCallback {
boolean shouldTerminate() throws InterruptedException;
}
// wrappers for some native methods with a different number of arguments
public static int msat_all_sat(long e, long[] important, AllSatModelCallback func)
throws InterruptedException {
return msat_all_sat(e, important, important.length, func);
}
/**
* Solve environment and check for satisfiability. Return true if sat, false if unsat.
*
* @throws SolverException if a mathsat problem occured
* @throws IllegalStateException in all other problematic cases
*/
public static boolean msat_check_sat(long e)
throws InterruptedException, IllegalStateException, SolverException {
return processSolveResult(e, msat_solve(e));
}
public static boolean msat_check_sat_with_assumptions(long e, long[] assumptions)
throws InterruptedException, IllegalStateException, SolverException {
return processSolveResult(e, msat_solve_with_assumptions(e, assumptions, assumptions.length));
}
private static final ImmutableSet<String> ALLOWED_SOLVE_FAILURE_MESSAGES =
ImmutableSet.of(
"unsupported",
"unimplemented",
"can't produce proofs",
"non-integer model value",
"build_model: too many iterations",
"eager fp solver does not support proof generation",
"FP<->BV combination unsupported by the current configuration");
private static boolean processSolveResult(long e, int resultCode)
throws IllegalStateException, SolverException {
switch (resultCode) {
case MSAT_SAT:
return true;
case MSAT_UNSAT:
return false;
default:
String msg = Strings.emptyToNull(msat_last_error_message(e));
if (ALLOWED_SOLVE_FAILURE_MESSAGES.contains(msg)) {
// This is not a bug in our code, but a problem of MathSAT
throw new SolverException(msg);
}
String code = (resultCode == MSAT_UNKNOWN) ? "\"unknown\"" : String.valueOf(resultCode);
throw new IllegalStateException(
"msat_solve returned " + code + (msg != null ? ": " + msg : ""));
}
}
static class NamedTermsWrapper {
final long[] terms;
final String[] names;
NamedTermsWrapper(long[] pTerms, String[] pNames) {
terms = pTerms;
names = pNames;
}
}
public static long msat_get_interpolant(long e, int[] groups_of_a) {
return msat_get_interpolant(e, groups_of_a, groups_of_a.length);
}
/*
* Environment creation
*/
public static native long msat_create_config();
public static native void msat_destroy_config(long cfg);
public static native long msat_create_env(long cfg);
public static native long msat_create_shared_env(long cfg, long sibling);
public static native void msat_destroy_env(long e);
@CheckReturnValue
private static native int msat_set_option(long cfg, String option, String value);
public static void msat_set_option_checked(long cfg, String option, String value)
throws IllegalArgumentException {
int retval = msat_set_option(cfg, option, value);
if (retval != 0) {
throw new IllegalArgumentException(
"Could not set Mathsat option \"" + option + "=" + value + "\", error code " + retval);
}
}
public static native long msat_get_bool_type(long e);
public static native long msat_get_rational_type(long e);
public static native long msat_get_integer_type(long e);
public static native long msat_get_bv_type(long e, int size);
public static native long msat_get_array_type(long e, long itp, long etp);
public static native long msat_get_array_index_type(long e, long t);
public static native long msat_get_array_element_type(long e, long t);
public static native long msat_get_fp_type(long e, int exp_with, int mant_with);
public static native long msat_get_fp_roundingmode_type(long e);
public static native long msat_get_simple_type(long e, String name);
public static native long msat_get_function_type(
long e, long[] paramTypes, int size, long returnType);
public static native long msat_get_enum_type(long e, String name, int size, String[] elements);
public static native boolean msat_is_bool_type(long e, long t);
public static native boolean msat_is_rational_type(long e, long t);
public static native boolean msat_is_integer_type(long e, long t);
public static native boolean msat_is_bv_type(long e, long t);
public static native int msat_get_bv_type_size(long e, long t);
public static native boolean msat_is_array_type(long e, long t);
public static native boolean msat_is_fp_type(long e, long t);
public static native int msat_get_fp_type_exp_width(long e, long t);
public static native int msat_get_fp_type_mant_width(long e, long t);
public static native boolean msat_is_fp_roundingmode_type(long e, long t);
public static native boolean msat_is_enum_type(long e, long t);
public static native long[] msat_get_enum_constants(long e, long t);
public static native boolean msat_type_equals(long t1, long t2);
public static native String msat_type_repr(long t);
public static native long msat_declare_function(long e, String name, long t);
/*
* Term creation
*/
public static native long msat_make_true(long e);
public static native long msat_make_false(long e);
public static native long msat_make_iff(long e, long t1, long t2);
public static native long msat_make_or(long e, long t1, long t2);
public static native long msat_make_and(long e, long t1, long t2);
public static native long msat_make_not(long e, long t1);
public static native long msat_make_equal(long e, long t1, long t2);
public static native long msat_make_eq(long e, long t1, long t2);
public static native long msat_make_leq(long e, long t1, long t2);
public static native long msat_make_plus(long e, long t1, long t2);
public static native long msat_make_times(long e, long t1, long t2);
public static native long msat_make_divide(long e, long t1, long t2);
public static native long msat_make_floor(long e, long t);
public static native long msat_make_pi(long e);
public static native long msat_make_exp(long e, long t);
public static native long msat_make_sin(long e, long t);
public static native long msat_make_log(long e, long t);
public static native long msat_make_pow(long e, long tb, long te);
public static native long msat_make_asin(long e, long t);
public static native long msat_make_number(long e, String num_rep);
public static native long msat_make_int_number(long e, int value);
public static native long msat_make_int_modular_congruence(
long e, String modulo, long t1, long t2);
public static native long msat_make_term_ite(long e, long c, long tt, long te);
public static native long msat_make_constant(long e, long var);
public static native long msat_make_uf(long e, long func, long[] args);
public static native long msat_make_array_read(long e, long arr, long idx);
public static native long msat_make_array_write(long e, long arr, long idx, long elem);
public static native long msat_make_array_const(long e, long arrayType, long elem);
public static native long msat_make_int_to_bv(long e, int width, long t);
public static native long msat_make_int_from_ubv(long e, long t);
public static native long msat_make_int_from_sbv(long e, long t);
public static native long msat_make_forall(long e, long var, long body);
public static native long msat_make_exists(long e, long var, long body);
public static native long msat_make_variable(long e, String name, long type);
public static long msat_existentially_quantify(long env, long term, long[] args) {
return msat_existentially_quantify(env, term, args, args.length);
}
public static native long msat_existentially_quantify(long e, long t, long[] args, int n);
public static native long msat_make_bv_number(long e, String numRep, int width, int base);
public static native long msat_make_bv_int_number(long e, int value, int width);
public static native long msat_make_bv_concat(long e, long t1, long t2);
/**
* Returns a term representing the selection of t[msb:lsb].
*
* @param e The environment of the definition
* @param msb The most significant bit of the selection.
* @param lsb The least significant bit of the selection.
* @param t The argument.
* @return a term representing the selection of t[msb:lsb].
*/
public static native long msat_make_bv_extract(long e, int msb, int lsb, long t);
public static native long msat_make_bv_or(long e, long t1, long t2);
public static native long msat_make_bv_xor(long e, long t1, long t2);
public static native long msat_make_bv_and(long e, long t1, long t2);
public static native long msat_make_bv_not(long e, long t);
public static native long msat_make_bv_lshl(long e, long t1, long t2);
public static native long msat_make_bv_lshr(long e, long t1, long t2);
public static native long msat_make_bv_ashr(long e, long t1, long t2);
public static native long msat_make_bv_zext(long e, int amount, long t);
public static native long msat_make_bv_sext(long e, int amount, long t);
public static native long msat_make_bv_plus(long e, long t1, long t2);
public static native long msat_make_bv_minus(long e, long t1, long t2);
public static native long msat_make_bv_neg(long e, long t);
public static native long msat_make_bv_times(long e, long t1, long t2);
public static native long msat_make_bv_udiv(long e, long t1, long t2);
public static native long msat_make_bv_urem(long e, long t1, long t2);
public static native long msat_make_bv_sdiv(long e, long t1, long t2);
public static native long msat_make_bv_srem(long e, long t1, long t2);
public static native long msat_make_bv_ult(long e, long t1, long t2);
public static native long msat_make_bv_uleq(long e, long t1, long t2);
public static native long msat_make_bv_slt(long e, long t1, long t2);
public static native long msat_make_bv_sleq(long e, long t1, long t2);
public static native long msat_make_bv_rol(long e, int size, long t);
public static native long msat_make_bv_ror(long e, int size, long t);
public static native long msat_make_bv_comp(long e, long t1, long t2);
public static native long msat_make_fp_roundingmode_nearest_even(long e);
public static native long msat_make_fp_roundingmode_zero(long e);
public static native long msat_make_fp_roundingmode_plus_inf(long e);
public static native long msat_make_fp_roundingmode_minus_inf(long e);
public static native long msat_make_fp_equal(long e, long t1, long t2);
public static native long msat_make_fp_lt(long e, long t1, long t2);
public static native long msat_make_fp_leq(long e, long t1, long t2);
public static native long msat_make_fp_neg(long e, long t);
public static native long msat_make_fp_plus(long e, long rounding, long t1, long t2);
public static native long msat_make_fp_minus(long e, long rounding, long t1, long t2);
public static native long msat_make_fp_times(long e, long rounding, long t1, long t2);
public static native long msat_make_fp_div(long e, long rounding, long t1, long t2);
public static native long msat_make_fp_sqrt(long e, long rounding, long t);
public static native long msat_make_fp_abs(long e, long t);
public static native long msat_make_fp_max(long e, long t1, long t2);
public static native long msat_make_fp_min(long e, long t1, long t2);
public static native long msat_make_fp_round_to_int(long e, long rounding, long t);
public static native long msat_make_fp_cast(
long e, long exp_w, long mant_w, long rounding, long t);
public static native long msat_make_fp_to_sbv(long e, long width, long rounding, long t);
public static native long msat_make_fp_to_ubv(long e, long width, long rounding, long t);
public static native long msat_make_fp_from_sbv(
long e, long exp_w, long mant_w, long rounding, long t);
public static native long msat_make_fp_from_ubv(
long e, long exp_w, long mant_w, long rounding, long t);
public static native long msat_make_fp_as_ieeebv(long e, long t);
public static native long msat_make_fp_from_ieeebv(long e, long exp_w, long mant_w, long t);
public static native long msat_make_fp_isnan(long e, long t);
public static native long msat_make_fp_isinf(long e, long t);
public static native long msat_make_fp_iszero(long e, long t);
public static native long msat_make_fp_issubnormal(long e, long t);
public static native long msat_make_fp_isnormal(long e, long t);
public static native long msat_make_fp_isneg(long e, long t);
public static native long msat_make_fp_ispos(long e, long t);
public static native long msat_make_fp_plus_inf(long e, long exp_w, long mant_w);
public static native long msat_make_fp_minus_inf(long e, long exp_w, long mant_w);
public static native long msat_make_fp_nan(long e, long exp_w, long mant_w);
public static native long msat_make_fp_rat_number(
long e, String numRep, long exp_w, long mant_w, long rounding);
public static native long msat_make_fp_bits_number(
long e, String bitRep, long exp_w, long mant_w);
/**
* Creates a term from a declaration and a list of arguments.
*
* <p>Precondition: The length of {@code args} should be equal to the arity of {@code d}
*
* @param e msat_env The environment in which to create the term
* @param d msat_decl The declaration
* @param args msat_term[] The arguments
* @return msat_term The created term, or a t s.t. ::MSAT_ERROR_TERM(t) is true in case of errors.
*/
public static native long msat_make_term(long e, long d, long[] args);
public static native long msat_make_copy_from(long e, long t, long src);
public static native long msat_apply_substitution(long e, long t, int s, long[] from, long[] to);
public static long msat_simplify(long env, long formula, long[] to_protect) {
return msat_simplify(env, formula, to_protect, to_protect.length);
}
public static native long msat_simplify(
long e, long formula, long[] to_protect, int num_to_protect);
/*
* Term access and navigation
*/
public static native int msat_term_id(long t);
public static native int msat_term_arity(long t);
public static native long msat_term_get_arg(long t, int n);
public static native long msat_term_get_type(long t);
public static native boolean msat_term_is_true(long e, long t);
public static native boolean msat_term_is_false(long e, long t);
public static native boolean msat_term_is_boolean_constant(long e, long t);
public static native boolean msat_term_is_atom(long e, long t);
public static native boolean msat_term_is_number(long e, long t);
public static native boolean msat_term_is_and(long e, long t);
public static native boolean msat_term_is_or(long e, long t);
public static native boolean msat_term_is_not(long e, long t);
public static native boolean msat_term_is_iff(long e, long t);
public static native boolean msat_term_is_term_ite(long e, long t);
public static native boolean msat_term_is_constant(long e, long t);
public static native boolean msat_term_is_uf(long e, long t);
public static native boolean msat_term_is_equal(long e, long t);
public static native boolean msat_term_is_leq(long e, long t);
public static native boolean msat_term_is_plus(long e, long t);
public static native boolean msat_term_is_times(long e, long t);
public static native boolean msat_term_is_divide(long e, long t);
public static native boolean msat_term_is_floor(long e, long t);
public static native boolean msat_term_is_pi(long e, long t);
public static native boolean msat_term_is_exp(long e, long t);
public static native boolean msat_term_is_sin(long e, long t);
public static native boolean msat_term_is_log(long e, long t);
public static native boolean msat_term_is_pow(long e, long t);
public static native boolean msat_term_is_asin(long e, long t);
public static native boolean msat_term_is_array_read(long e, long t);
public static native boolean msat_term_is_array_write(long e, long t);
public static native boolean msat_term_is_array_const(long e, long t);
public static native boolean msat_term_is_int_to_bv(long e, long t);
public static native boolean msat_term_is_int_from_ubv(long e, long t);
public static native boolean msat_term_is_int_from_sbv(long e, long t);
public static native boolean msat_term_is_bv_concat(long e, long t);
public static native boolean msat_term_is_bv_extract(long e, long t);
public static native boolean msat_term_is_bv_or(long e, long t);
public static native boolean msat_term_is_bv_xor(long e, long t);
public static native boolean msat_term_is_bv_and(long e, long t);
public static native boolean msat_term_is_bv_not(long e, long t);
public static native boolean msat_term_is_bv_plus(long e, long t);
public static native boolean msat_term_is_bv_minus(long e, long t);
public static native boolean msat_term_is_bv_times(long e, long t);
public static native boolean msat_term_is_bv_neg(long e, long t);
public static native boolean msat_term_is_bv_udiv(long e, long t);
public static native boolean msat_term_is_bv_urem(long e, long t);
public static native boolean msat_term_is_bv_sdiv(long e, long t);
public static native boolean msat_term_is_bv_srem(long e, long t);
public static native boolean msat_term_is_bv_ult(long e, long t);
public static native boolean msat_term_is_bv_uleq(long e, long t);
public static native boolean msat_term_is_bv_slt(long e, long t);
public static native boolean msat_term_is_bv_sleq(long e, long t);
public static native boolean msat_term_is_bv_lshl(long e, long t);
public static native boolean msat_term_is_bv_lshr(long e, long t);
public static native boolean msat_term_is_bv_ashr(long e, long t);
public static native boolean msat_term_is_bv_zext(long e, long t);
public static native boolean msat_term_is_bv_sext(long e, long t);
public static native boolean msat_term_is_bv_rol(long e, long t);
public static native boolean msat_term_is_bv_ror(long e, long t);
public static native boolean msat_term_is_bv_comp(long e, long t);
public static native boolean msat_term_is_quantifier(long e, long t);
public static native boolean msat_term_is_forall(long e, long t);
public static native boolean msat_term_is_exists(long e, long t);
public static native boolean msat_term_is_variable(long e, long t);
// public static native int msat_visit_term(long e, msat_visit_term_callback func)
public static native long msat_find_decl(long e, String symbol);
/**
* Returns the declaration associated to {@code t} (if any).
*
* <p>If {@code t} is not a constant or a function application, the returned value \a ret will be
* s.t. MSAT_ERROR_DECL(ret) is true
*
* @param t msat_term The term for which to retrieve the declaration
* @return msat_decl If {@code t} is a constant, its declaration is returned; if it is an uif, the
* declaration of the function is returned; otherwise, a {@code ret} s.t. MSAT_ERROR_DECL(ret)
* is true is returned
*/
public static native long msat_term_get_decl(long t);
public static native int msat_decl_id(long d);
public static native long msat_decl_get_return_type(long d);
/**
* @param env msat_env
* @param d msat_decl
* @return msat_symbol_tag
*/
public static native int msat_decl_get_tag(long env, long d);
public static native int msat_decl_get_arity(long d);
public static native long msat_decl_get_arg_type(long d, int n);
public static native String msat_decl_repr(long d);
public static native String msat_decl_get_name(long d);
public static native String msat_term_repr(long t);
/*
* Parsing and writing formulas.
*/
public static native long msat_from_string(long e, String data);
public static native long msat_from_smtlib1(long e, String data);
public static native long msat_from_smtlib2(long e, String data);
public static native String msat_to_smtlib1(long e, long t);
public static native String msat_to_smtlib2(long e, long t);
public static native String msat_to_smtlib2_term(long e, long t);
public static native String msat_named_list_to_smtlib2(long e, NamedTermsWrapper w);
public static native NamedTermsWrapper msat_named_list_from_smtlib2(long e, String s);
/*
* Problem solving
*/
public static native void msat_push_backtrack_point(long e);
public static native void msat_pop_backtrack_point(long e);
public static native int msat_num_backtrack_points(long e);
public static native void msat_reset_env(long e);
public static native void msat_assert_formula(long e, long formula);
// public static native int msat_add_preferred_for_branching(long e, long termBoolvar);
// public static native int msat_clear_preferred_for_branching(long e)
private static native int msat_solve(long e) throws InterruptedException;
private static native int msat_solve_with_assumptions(
long e, long[] assumptions, int numAssumptions) throws InterruptedException;
private static native int msat_all_sat(
long e, long[] important, int num_important, AllSatModelCallback func)
throws InterruptedException;
public static native long[] msat_get_asserted_formulas(long e);
public static native long[] msat_get_theory_lemmas(long e);
/*
* Interpolation
*/
public static native int msat_create_itp_group(long e);
public static native void msat_set_itp_group(long e, int group);
private static native long msat_get_interpolant(long e, int[] groups_of_a, int n);
/*
* Model computation
*/
public static native long msat_get_model_value(long e, long term);
public static native long msat_get_model(long e);
public static native void msat_destroy_model(long model);
public static native long msat_model_create_iterator(long model);
/**
* Evaluates the input term in the given model.
*
* @param model msat_model The model used for the evaluation.
* @param term msat_term The term to evaluate.
* @return the value for {@code t} in {@code m}. Use MSAT_ERROR_TERM() to check for errors.
*/
public static native long msat_model_eval(long model, long term);
private static native long msat_create_model_iterator(long e);
public static native boolean msat_model_iterator_has_next(long i);
public static native boolean msat_model_iterator_next(long i, long[] t, long[] v);
public static native void msat_destroy_model_iterator(long i);
/*
* Unsat core computation
*/
public static native long[] msat_get_unsat_assumptions(long e);
public static native long[] msat_get_unsat_core(long e);
/*
* Special functions
*/
public static native long msat_set_termination_callback(long e, TerminationCallback callback);
public static native void msat_free_termination_callback(long t);
public static native String msat_get_version();
public static native String msat_get_version_id();
public static native String msat_last_error_message(long e);
/* Optimization **/
/*
* OptiMathSAT - environment creation
*/
public static native long msat_create_opt_env(long cfg);
public static native long msat_create_shared_opt_env(long cfg, long sibling);
/*
* OptiMathSAT - objectives creation
*/
/**
* Create new objective 'min(term)' with optional optimization local interval [lower, upper[. Push
* onto the stack using assert_objective.
*
* @param e msat_env The environment in which to operate.
* @param term msat_term The term to be minimized.
*/
public static native long msat_make_minimize(long e, long term);
public static native long msat_make_minimize_signed(long e, long term);
/**
* Create the new objective 'max(term)' with optional optimization local interval ]local, upper].
* Push onto the stack using assert_objective .
*
* @param e msat_env The environment in which to operate.
* @param term msat_term The term to be maximized.
*/
public static native long msat_make_maximize(long e, long term);
public static native long msat_make_maximize_signed(long e, long term);
/**
* Create the new objective 'min(max(term0), ..., max(termN))' with optional optimization local
* interval ]lower, upper]. Push onto the stack using assert_objective
*
* @param e msat_env The environment in which to operate.
* @param len size_t The size of terms.
* @param terms msat_term[] The array of terms to be optimized.
*/
public static native long msat_make_minmax(long e, int len, long[] terms);
public static native long msat_make_minmax_signed(long e, int len, long[] terms);
/**
* Create the new objective 'max(min(term0), ..., min(termN))' with optional optimization local
* interval [lower, upper[. Push onto the stack using assert_objective
*
* @param e msat_env The environment in which to operate.
* @param len size_t The size of terms.
* @param terms msat_term[] The array of terms to be optimized.
*/
public static native long msat_make_maxmin(long e, int len, long[] terms);
public static native long msat_make_maxmin_signed(long e, int len, long[] terms);
/**
* \brief Associate a weight to a term declaration with respect to a MaxSMT group identified by a
* common id label. Assert-soft constraints are ineffective unless the id label is used by an
* objective that is pushed on the stack.
*
* <p>\param e msat_env The environment in which to operate. \param term msat_term The term to
* which a weight is attached. \param weight msat_term The weight of not satisfying this
* soft-clause. \param upper The MaxSMT sum onto which the weight contribution is added.
*/
public static native void msat_assert_soft_formula(long e, long term, long weight, String id);
/**
* Returns general search statistics.
*
* @param e msat_env The environment in which to operate.
* @return A string which provides some search statistics information on the search.
*/
public static native String msat_get_search_stats(long e);
/*
* OptiMathSAT - objective stack iterator
*/
/**
* Creates an objective iterator NOTE: an objective iterator, and any of its references, should
* only be instantiated after a ::msat_solve call, and prior to any further
* push/pop/assert_formula action. Otherwise, the behaviour is undefined.
*
* @param e msat_env The environment in use
* @return msat_objective_iterator an iterator for the current objectives
*/
public static native long msat_create_objective_iterator(long e);
/**
* Checks whether {@code i} can be incremented.
*
* @param i msat_objective_iterator An objective iterator
* @return nonzero if \a i can be incremented, zero otherwise
*/
public static native int msat_objective_iterator_has_next(long i);
/**
* Returns the next objective, and increments the given iterator.
*
* @param i msat_objective_iterator The objective iterator to increment.
* @param o msat_objective* Output value for the next objective in the stack.
* @return nonzero in case of error.
*/
public static native int msat_objective_iterator_next(long i, long[] o);
/**
* Destroys an objective iterator.
*
* @param i msat_objective_iterator the iterator to destroy.
*/
public static native void msat_destroy_objective_iterator(long i);
/*
* OptiMathSAT - functions for objective state inspection
*/
/**
* Returns the optimization search state of the given objective.
*
* @param e msat_env The environment in which to operate.
* @param o msat_objective The objective.
* @return msat_result ::MSAT_SAT if objective has a solution, ::MSAT_UNSAT if objective is
* unsatisfiable, and ::MSAT_UNKNOWN if there was some error or if satisfiability/optimality
* could not be determined.
*/
public static native int msat_objective_result(long e, long o);
/**
* Returns the term which is optimized by the objective.
*
* @param e msat_env The environment in which to operate.
* @param o msat_objective The objective.
* @return msat_term representation of the objective function
*/
public static native long msat_objective_get_term(long e, long o);
/**
* Returns the objective optimization type (min or max).
*
* @param e msat_env The environment in which to operate.
* @param o msat_objective The objective.
* @return msat_objective_type ::MSAT_OBJECTIVE_MINIMIZE or ::MSAT_OBJECTIVE_MAXIMIZE
*/
public static native long msat_objective_get_type(long e, long o);
/**
* Load into memory the model associated with the given objective, provided that it is
* satisfiable.
*
* @param e msat_env The environment in which to operate.
* @param o msat_objective The objective providing the model.
*/
public static native void msat_load_objective_model(long e, long o);
/**
* Returns optimization search statistics.
*
* @return A string which provides some search statistics information on the optimization search
* of the given objective. The string must be deallocated by the user with ::msat_free().
*/
public static native String msat_objective_get_search_stats(long e, long o);
/**
* Determines if the given objective value is unbounded.
*
* @param e msat_env The environment in which to operate.
* @param o msat_objective The objective providing the value.
* @param i msat_objective_value The objective field to be tested.
* @return 1 if unbounded, 0 if not, -1 on error.
*/
public static native int msat_objective_value_is_unbounded(long e, long o, int i);
/**
* Determines if the given objective value is +INF.
*
* @param e msat_env The environment in which to operate.
* @param o msat_objective The objective providing the value.
* @param i msat_objective_value The objective field to be tested.
* @return 1 if +INF, 0 if not, -1 on error.
*/
public static native int msat_objective_value_is_plus_inf(long e, long o, int i);
/**
* Determines if the given objective value is -INF.
*
* @param e msat_env The environment in which to operate.
* @param o msat_objective The objective providing the value.
* @param i msat_objective_value The objective field to be tested.
* @return 1 if -INF, 0 if not, -1 on error.
*/
public static native int msat_objective_value_is_minus_inf(long e, long o, int i);
/**
* Determines if the given objective value is strict, (e.g. if term(i) = k and strict(i) = TRUE,
* then actual value of 'i' is k+epsilon, with epsilon being any small positive value).
*
* @param e msat_env The environment in which to operate.
* @param o msat_objective The objective providing the value.
* @param i msat_objective_value The objective field to be tested.
* @return 1 if strict, 0 if not, -1 on error.
*/
public static native int msat_objective_value_is_strict(long e, long o, int i);
/**
* Returns term representation of the given objective value. NOTE: the representation IS imprecise
* if objective value is strict.
*
* @param e msat_env The environment in which to operate.
* @param o msat_objective The objective providing the value.
* @param i msat_objective_value The objective field to retrieve.
* @param fin The symbol / positive value representing infinity. If equal to NULL
* (MSAT_ERROR_TERM), OptiMathSAT picks his own value.
* @param eps The symbol / positive value representing epsilon. If equal to NULL
* (MSAT_ERROR_TERM), OptiMathSAT picks his own value.
* @return msat_term term associated to the objective value, or msat_error_term on error.
*/
public static native long msat_objective_value_term(long e, long o, int i, long fin, long eps);
/**
* Performs garbage collection on the given environment.
*
* <p>This function will perform garbage collection on the given environment. All the internal
* caches of the environment will be cleared (including those in the active solvers and
* preprocessors). If the environment is not shared, all the terms that are not either in {@code
* tokeep} or in the current asserted formulas will be deleted.
*
* @param env msat_env The environment in which to operate.
* @param tokeep List of terms to not delete.
* @param num_tokeep Size of the {@code tokeep} array.
* @return zero on success, nonzero on error.
*/
private static native int msat_gc_env(long env, long[] tokeep, int num_tokeep);
/**
* Push objective on stack.
*
* @param e msat_env The environment in which to operate.
* @param o msat_objective to push on the stack
*/
public static native void msat_assert_objective(long e, long o);
}
| 40,568 | 37.637143 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5NativeApiTest.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static com.google.common.truth.Truth.assertThat;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_assert_formula;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_check_sat;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_create_config;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_create_env;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_decl_get_arity;
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_destroy_config;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_destroy_model_iterator;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_from_smtlib2;
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_enum_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_model;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_model_value;
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_enum_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_make_asin;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_eq;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_equal;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_exp;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_log;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_not;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_number;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_pi;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_pow;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_sin;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_term;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_times;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_variable;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_model_create_iterator;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_model_iterator_has_next;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_model_iterator_next;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_pop_backtrack_point;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_push_backtrack_point;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_set_option_checked;
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_pi;
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_equals;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_type_repr;
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;
import org.sosy_lab.java_smt.api.SolverException;
public class Mathsat5NativeApiTest extends Mathsat5AbstractNativeApiTest {
private long const0;
private long const1;
private long var;
@BeforeClass
public static void loadMathsat() {
try {
Mathsat5SolverContext.loadLibrary(NativeLibraries::loadLibrary);
} catch (UnsatisfiedLinkError e) {
throw new AssumptionViolatedException("MathSAT5 is not available", e);
}
}
@Before
public void createEnvironment() {
long cfg = msat_create_config();
msat_set_option_checked(cfg, "model_generation", "true");
// msat_set_option_checked(cfg, "theory.la.split_rat_eq", "false");
env = msat_create_env(cfg);
msat_destroy_config(cfg);
const0 = msat_make_number(env, "0");
const1 = msat_make_number(env, "1");
long rationalType = msat_get_rational_type(env);
var = msat_make_variable(env, "rat", rationalType);
}
/** x == 0 and sin(x) == 0 SAT; x == 1 and sin(x) == 0 UNSAT. */
@Test
public void sinTest() throws IllegalStateException, InterruptedException, SolverException {
long sin = msat_make_sin(env, var);
msat_push_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, var, const0));
msat_assert_formula(env, msat_make_equal(env, sin, const0));
assertThat(msat_check_sat(env)).isTrue();
msat_pop_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, var, const1));
msat_assert_formula(env, msat_make_equal(env, sin, const0));
assertThat(msat_check_sat(env)).isFalse();
}
/** x == 0 and e^x = 1 SAT; x == 1 and e^x == 1 UNSAT. */
@Test
public void expTest() throws IllegalStateException, InterruptedException, SolverException {
long exp = msat_make_exp(env, var);
msat_push_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, var, const0));
msat_assert_formula(env, msat_make_equal(env, exp, const1));
assertThat(msat_check_sat(env)).isTrue();
msat_pop_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, var, const1));
msat_assert_formula(env, msat_make_equal(env, exp, const1));
assertThat(msat_check_sat(env)).isFalse();
}
/**
* Testing is_pi(x) and x == pi true (Works); Tried x == pi and sin(x) == 0 SAT but solver
* calculates endlessly.
*/
@Ignore
public void piTest() throws IllegalStateException, InterruptedException, SolverException {
long pi = msat_make_pi(env);
long sin = msat_make_sin(env, var);
assertThat(msat_term_is_pi(env, pi)).isTrue();
assertThat(msat_term_is_pi(env, const0)).isFalse();
msat_assert_formula(env, msat_make_eq(env, sin, const0));
msat_assert_formula(env, msat_make_eq(env, var, pi));
assertThat(msat_check_sat(env)).isTrue();
}
/** Similar problem as sin(pi); Calculates endlessly (even asin(0) == 0). */
@Ignore
public void asinTest() throws IllegalStateException, InterruptedException, SolverException {
long asin = msat_make_asin(env, var);
msat_push_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, var, const0));
msat_assert_formula(env, msat_make_equal(env, asin, const0));
assertThat(msat_check_sat(env)).isTrue();
msat_pop_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, var, const1));
msat_assert_formula(env, msat_make_equal(env, asin, const0));
assertThat(msat_check_sat(env)).isFalse();
}
/**
* log(term) == natural log of term Similar problem as asin; Calculates endlessly even with
* trivial formulas as ln(1) == 0 or log(e^1) == 1.
*/
@Ignore
public void logTest() throws IllegalStateException, InterruptedException, SolverException {
// exp(1) == e
long logE = msat_make_log(env, msat_make_exp(env, var));
long logVar = msat_make_log(env, var);
msat_push_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, var, const1));
msat_assert_formula(env, msat_make_equal(env, logVar, const0));
assertThat(msat_check_sat(env)).isTrue();
msat_pop_backtrack_point(env);
msat_push_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, var, const1));
msat_assert_formula(env, msat_make_equal(env, logE, const1));
assertThat(msat_check_sat(env)).isTrue();
msat_pop_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, var, const1));
msat_assert_formula(env, msat_make_equal(env, logVar, const1));
assertThat(msat_check_sat(env)).isFalse();
}
/**
* First we test: var * var == var ^ 2 && var != 1 because 1*1*1*1... == 1 && var != 0 after that
* we test: var * var != var ^ 3 && var != 1 && var != 0.
*/
@Test
public void powTest() throws IllegalStateException, InterruptedException, SolverException {
long const2 = msat_make_number(env, "2");
long const3 = msat_make_number(env, "3");
long pow2 = msat_make_pow(env, var, const2);
long pow3 = msat_make_pow(env, var, const3);
long mult2 = msat_make_times(env, var, var);
msat_assert_formula(
env, msat_make_not(env, msat_make_equal(env, var, msat_make_number(env, "1"))));
msat_assert_formula(
env, msat_make_not(env, msat_make_equal(env, var, msat_make_number(env, "0"))));
msat_push_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, pow2, mult2));
assertThat(msat_check_sat(env)).isTrue();
msat_pop_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, pow3, mult2));
assertThat(msat_check_sat(env)).isFalse();
}
@Test
public void typeTest() throws IllegalStateException {
long const2 = msat_make_number(env, "2");
long const3 = msat_make_number(env, "3");
long i = msat_make_variable(env, "i", msat_get_integer_type(env));
long r = msat_make_variable(env, "r", msat_get_rational_type(env));
checkRationalType(msat_make_pi(env));
checkRationalType(msat_make_sin(env, r));
checkRationalType(msat_make_exp(env, r));
checkRationalType(msat_make_asin(env, r));
checkRationalType(msat_make_log(env, msat_make_exp(env, r)));
checkRationalType(msat_make_log(env, r));
checkRationalType(msat_make_pi(env));
checkRationalType(msat_make_sin(env, i));
checkRationalType(msat_make_exp(env, i));
checkRationalType(msat_make_asin(env, i));
checkRationalType(msat_make_log(env, msat_make_exp(env, i)));
checkRationalType(msat_make_log(env, i));
checkRationalType(msat_make_pow(env, r, const2));
checkRationalType(msat_make_pow(env, r, const3));
checkRationalType(msat_make_times(env, r, r));
checkIntegerType(msat_make_pow(env, i, const2));
checkIntegerType(msat_make_pow(env, i, const3));
checkIntegerType(msat_make_times(env, i, i));
checkRationalType(msat_make_pow(env, i, i));
checkRationalType(msat_make_times(env, i, r));
checkRationalType(msat_make_pow(env, r, r));
checkRationalType(msat_make_times(env, r, r));
}
private void checkRationalType(long term) {
assertThat(msat_type_equals(msat_term_get_type(term), msat_get_rational_type(env))).isTrue();
}
private void checkIntegerType(long term) {
assertThat(msat_type_equals(msat_term_get_type(term), msat_get_integer_type(env))).isTrue();
}
private static final String QUERY =
"(declare-fun __VERIFIER_nondet_int!2@ () Int)"
+ "(declare-fun |main::length@3| () Int)"
+ "(declare-fun |__ADDRESS_OF___VERIFIER_successful_alloc_*void#1@| () Int)"
+ "(declare-fun |main::arr@3| () Int)"
+ "(declare-fun |main::a@2| () Int)"
+ "(declare-fun *int@1 () (Array Int Int))"
+ "(declare-fun *int@2 () (Array Int Int))"
+ "(declare-fun |main::__CPAchecker_TMP_0@2| () Int)"
+ "(declare-fun |main::a@3| () Int)"
+ "(define-fun v8 () Int 0)"
+ "(define-fun v13 () Int 4)"
+ "(define-fun v14 () Int __VERIFIER_nondet_int!2@)"
+ "(define-fun v15 () Int |main::length@3|)"
+ "(define-fun v16 () Bool (= v14 v15))"
+ "(define-fun v17 () Int 1)"
+ "(define-fun v18 () Bool (<= v17 v15))"
+ "(define-fun v22 () Bool (and v16 v18))"
+ "(define-fun v30 () Int |__ADDRESS_OF___VERIFIER_successful_alloc_*void#1@|)"
+ "(define-fun v31 () Bool (<= v30 v8))"
+ "(define-fun v32 () Bool (not v31))"
+ "(define-fun v33 () Bool ((_ divisible 4) (- v30 v8)))"
+ "(define-fun v35 () Int (- 4))"
+ "(define-fun v36 () Bool (<= v30 v35))"
+ "(define-fun v37 () Bool (not v36))"
+ "(define-fun v41 () Int |main::arr@3|)"
+ "(define-fun v42 () Bool (= v30 v41))"
+ "(define-fun v43 () Bool (and v32 v33))"
+ "(define-fun v44 () Bool (and v37 v43))"
+ "(define-fun v48 () Bool (= v41 v8))"
+ "(define-fun v51 () Bool (not v48))"
+ "(define-fun v54 () Int (- 1))"
+ "(define-fun v56 () Int |main::a@2|)"
+ "(define-fun v57 () Int (* v54 v56))"
+ "(define-fun v58 () Int (+ v41 v57))"
+ "(define-fun v2300 () (Array Int Int) *int@1)"
+ "(define-fun v2304 () (Array Int Int) *int@2)"
+ "(define-fun v6120 () Int (select v2300 v56))"
+ "(define-fun v6121 () Int (select v2300 v41))"
+ "(define-fun v6122 () Bool (= v6120 v6121))"
+ "(define-fun v6123 () Bool (not v6122))"
+ "(define-fun v6135 () Int |main::__CPAchecker_TMP_0@2|)"
+ "(define-fun v6136 () Bool (= v56 v6135))"
+ "(define-fun v6139 () Int |main::a@3|)"
+ "(define-fun v6140 () Int (* v54 v6139))"
+ "(define-fun v6141 () Int (+ v56 v6140))"
+ "(define-fun v6142 () Bool (= v6141 v13))"
+ "(define-fun v6144 () Int (+ v6120 v6121))"
+ "(define-fun v6145 () (Array Int Int) (store v2300 v56 v6144))"
+ "(define-fun v6146 () Bool (= v2304 v6145))"
+ "(define-fun v18733 () Int (* v13 v15))"
+ "(define-fun v18735 () Int (+ v18733 v30))"
+ "(define-fun v18736 () Bool (<= v18735 v8))"
+ "(define-fun v18737 () Bool (not v18736))"
+ "(define-fun v18738 () Bool (and v44 v18737))"
+ "(define-fun v18739 () Bool (and v42 v18738))"
+ "(define-fun v18740 () Bool (and v22 v18739))"
+ "(define-fun v18741 () Bool (and v51 v18740))"
+ "(define-fun v18744 () Int (+ v18733 v58))"
+ "(define-fun v18745 () Bool (= v18744 v13))"
+ "(define-fun v18746 () Bool (and v18741 v18745))"
+ "(define-fun v18747 () Bool (and v6123 v18746))"
+ "(define-fun v18748 () Bool (and v6146 v18747))"
+ "(define-fun v18749 () Bool (and v6136 v18748))"
+ "(define-fun v18750 () Bool (and v6142 v18749))"
+ "(assert v18750)";
// The next method crashed with MathSAT5 version 5.6.4
// (NullPointer during iterator creation).
// The bug was reported and fixed with the next release.
@Test
public void modelIteratorTest()
throws IllegalStateException, InterruptedException, SolverException {
long parsedFormula = msat_from_smtlib2(env, QUERY);
msat_assert_formula(env, parsedFormula);
boolean isSat = msat_check_sat(env);
assertThat(isSat).isTrue();
long model = msat_get_model(env);
long iter = msat_model_create_iterator(model);
while (msat_model_iterator_has_next(iter)) {
long[] key = new long[1];
long[] value = new long[1];
// System.out.println("before crash");
@SuppressWarnings("unused")
boolean check = msat_model_iterator_next(iter, key, value); // crash here
// System.out.println(" " + check);
// String k = msat_term_repr(key[0]);
// System.out.println("after crash");
// String v = msat_term_repr(value[0]);
// System.out.println(k + " := " + v);
}
msat_destroy_model_iterator(iter);
}
private static final String LARGE_NUMBER_QUERY =
"(declare-fun a () Int) (assert (= a 10000000000000000000000001))";
@Test
public void invalidLargeNumberInModelTest()
throws IllegalStateException, InterruptedException, SolverException {
long parsed = msat_from_smtlib2(env, LARGE_NUMBER_QUERY);
msat_assert_formula(env, parsed);
boolean isSat = msat_check_sat(env);
assertThat(isSat).isTrue();
long model = msat_get_model(env);
long iter = msat_model_create_iterator(model);
while (msat_model_iterator_has_next(iter)) {
long[] key = new long[1];
long[] value = new long[1];
// System.out.println("before crash");
@SuppressWarnings("unused")
boolean check = msat_model_iterator_next(iter, key, value); // crash here
// System.out.println(" " + check);
// String k = msat_term_repr(key[0]);
// System.out.println("after crash");
// String v = msat_term_repr(value[0]);
// System.out.println(k + " := " + v);
}
msat_destroy_model_iterator(iter);
}
private static final String LIA_QUERY =
"(declare-fun |__ADDRESS_OF_main::a@| () Int)"
+ "(declare-fun |main::a@2| () Int)"
+ "(declare-fun *int@1 () (Array Int Int))"
+ "(declare-fun |main::p@2| () Int)"
+ "(declare-fun *int@2 () (Array Int Int))"
+ "(define-fun .8 () Int 0)"
+ "(define-fun .13 () Int |__ADDRESS_OF_main::a@|)"
+ "(define-fun .14 () Bool (<= .13 .8))"
+ "(define-fun .15 () Bool (not .14))"
+ "(define-fun .16 () Bool ((_ divisible 4) (- .13 .8)))"
+ "(define-fun .18 () Int (- 4))"
+ "(define-fun .19 () Bool (<= .13 .18))"
+ "(define-fun .20 () Bool (not .19))"
+ "(define-fun .21 () Int |main::a@2|)"
+ "(define-fun .22 () Bool (= .21 .8))"
+ "(define-fun .23 () Bool (and .15 .16))"
+ "(define-fun .24 () Bool (and .20 .23))"
+ "(define-fun .25 () Bool (and .22 .24))"
+ "(define-fun .26 () (Array Int Int) *int@1)"
+ "(define-fun .27 () Int (select .26 .13))"
+ "(define-fun .28 () Bool (= .21 .27))"
+ "(define-fun .29 () Int |main::p@2|)"
+ "(define-fun .30 () Bool (= .13 .29))"
+ "(define-fun .31 () Bool (and .28 .30))"
+ "(define-fun .32 () Bool (and .25 .31))"
+ "(define-fun .33 () Int 5)"
+ "(define-fun .34 () (Array Int Int) *int@2)"
+ "(define-fun .35 () (Array Int Int) (store .26 .13 .33))"
+ "(define-fun .36 () Bool (= .34 .35))"
+ "(define-fun .37 () Bool (and .32 .36))"
+ "(define-fun .38 () Int (select .34 .29))"
+ "(define-fun .39 () Bool (<= .38 .8))"
+ "(define-fun .40 () Bool (not .39))"
+ "(define-fun .43 () Bool (and .37 .40))"
+ "(assert .43)";
@Test
public void linearArithmeticModelTest()
throws IllegalStateException, InterruptedException, SolverException {
long parsed = msat_from_smtlib2(env, LIA_QUERY);
msat_assert_formula(env, parsed);
boolean isSat = msat_check_sat(env);
assertThat(isSat).isTrue();
long model = msat_get_model(env);
long iter = msat_model_create_iterator(model);
while (msat_model_iterator_has_next(iter)) {
long[] key = new long[1];
long[] value = new long[1];
@SuppressWarnings("unused")
boolean check = msat_model_iterator_next(iter, key, value); // crash here
// System.out.println(" " + check);
// String k = msat_term_repr(key[0]);
// System.out.println("after crash");
// String v = msat_term_repr(value[0]);
// System.out.println(k + " := " + v);
}
msat_destroy_model_iterator(iter);
}
@Test
public void evaluationWithoutModelTest()
throws IllegalStateException, InterruptedException, SolverException {
long x = msat_make_variable(env, "x", msat_get_integer_type(env));
long num = msat_make_number(env, "10");
msat_push_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, x, num));
assertThat(msat_check_sat(env)).isTrue();
boolean isSat = msat_check_sat(env);
assertThat(isSat).isTrue();
long value = msat_get_model_value(env, x);
assertThat(msat_term_repr(value)).isEqualTo("10");
}
@Test
public void enumTypeTest() throws SolverException, InterruptedException {
String[] colors = {"blue", "red", "green"};
// create enum type
long colorType = msat_get_enum_type(env, "Color", 3, colors);
assertThat(msat_type_repr(colorType)).isEqualTo("Color");
// check type
assertThat(msat_is_enum_type(env, colorType)).isTrue();
assertThat(msat_is_enum_type(env, msat_get_integer_type(env))).isFalse();
assertThat(msat_is_integer_type(env, colorType)).isFalse();
// check constants
long[] constantDecls = msat_get_enum_constants(env, colorType);
assertThat(constantDecls.length).isEqualTo(3);
for (int i = 0; i < colors.length; i++) {
assertThat(msat_decl_get_name(constantDecls[i])).isEqualTo(colors[i]);
assertThat(msat_decl_get_arity(constantDecls[i])).isEqualTo(0);
assertThat(msat_term_get_type(msat_make_term(env, constantDecls[i], new long[] {})))
.isEqualTo(colorType);
}
// check a simple assertion
var = msat_make_variable(env, "varColor", colorType);
long blue = msat_make_term(env, constantDecls[0], new long[] {});
long red = msat_make_term(env, constantDecls[1], new long[] {});
long green = msat_make_term(env, constantDecls[2], new long[] {});
// check 1
msat_push_backtrack_point(env);
msat_assert_formula(env, msat_make_equal(env, blue, var));
assertThat(msat_check_sat(env)).isTrue();
msat_pop_backtrack_point(env);
// chck 2
msat_push_backtrack_point(env);
msat_assert_formula(env, msat_make_not(env, msat_make_equal(env, blue, var)));
assertThat(msat_check_sat(env)).isTrue();
msat_assert_formula(env, msat_make_not(env, msat_make_equal(env, red, var)));
assertThat(msat_check_sat(env)).isTrue();
msat_assert_formula(env, msat_make_not(env, msat_make_equal(env, green, var)));
assertThat(msat_check_sat(env)).isFalse();
msat_pop_backtrack_point(env);
}
}
| 22,586 | 41.616981 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5NumeralFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_and;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_equal;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_floor;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_int_number;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_leq;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_not;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_number;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_plus;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_times;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_true;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_is_number;
import java.math.BigInteger;
import java.util.List;
import org.sosy_lab.java_smt.api.NumeralFormula;
import org.sosy_lab.java_smt.basicimpl.AbstractNumeralFormulaManager;
@SuppressWarnings("ClassTypeParameterName")
abstract class Mathsat5NumeralFormulaManager<
ParamFormulaType extends NumeralFormula, ResultFormulaType extends NumeralFormula>
extends AbstractNumeralFormulaManager<
Long, Long, Long, ParamFormulaType, ResultFormulaType, Long> {
final long mathsatEnv;
Mathsat5NumeralFormulaManager(
Mathsat5FormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
this.mathsatEnv = pCreator.getEnv();
}
@Override
protected boolean isNumeral(Long val) {
return msat_term_is_number(mathsatEnv, val);
}
@Override
protected Long makeNumberImpl(long pNumber) {
int i = (int) pNumber;
if (i == pNumber) { // fits in an int
return msat_make_int_number(mathsatEnv, i);
}
return msat_make_number(mathsatEnv, Long.toString(pNumber));
}
@Override
protected Long makeNumberImpl(BigInteger pI) {
return msat_make_number(mathsatEnv, pI.toString());
}
@Override
protected Long makeNumberImpl(String pI) {
return msat_make_number(mathsatEnv, pI);
}
protected abstract long getNumeralType();
@Override
protected Long makeVariableImpl(String var) {
return getFormulaCreator().makeVariable(getNumeralType(), var);
}
@Override
protected Long negate(Long pNumber) {
return msat_make_times(mathsatEnv, pNumber, msat_make_number(mathsatEnv, "-1"));
}
@Override
protected Long add(Long pNumber1, Long pNumber2) {
return msat_make_plus(mathsatEnv, pNumber1, pNumber2);
}
@Override
protected Long subtract(Long pNumber1, Long pNumber2) {
return msat_make_plus(mathsatEnv, pNumber1, negate(pNumber2));
}
@Override
protected Long multiply(Long pNumber1, Long pNumber2) {
return msat_make_times(mathsatEnv, pNumber1, pNumber2);
}
@Override
protected Long equal(Long pNumber1, Long pNumber2) {
return msat_make_equal(mathsatEnv, pNumber1, pNumber2);
}
@Override
protected Long distinctImpl(List<Long> pNumbers) {
// MathSat does not directly support this method, we need to build the whole term.
long r = msat_make_true(mathsatEnv);
for (int i = 0; i < pNumbers.size(); i++) {
for (int j = 0; j < i; j++) {
r = msat_make_and(mathsatEnv, r, makeNot(equal(pNumbers.get(i), pNumbers.get(j))));
}
}
return r;
}
@Override
protected Long greaterThan(Long pNumber1, Long pNumber2) {
return makeNot(lessOrEquals(pNumber1, pNumber2));
}
@Override
protected Long greaterOrEquals(Long pNumber1, Long pNumber2) {
return lessOrEquals(pNumber2, pNumber1);
}
private long makeNot(long n) {
return msat_make_not(mathsatEnv, n);
}
@Override
protected Long lessThan(Long pNumber1, Long pNumber2) {
return makeNot(lessOrEquals(pNumber2, pNumber1));
}
@Override
protected Long lessOrEquals(Long pNumber1, Long pNumber2) {
return msat_make_leq(mathsatEnv, pNumber1, pNumber2);
}
@Override
protected Long floor(Long pNumber) {
return msat_make_floor(mathsatEnv, pNumber);
}
}
| 4,521 | 31.532374 | 92 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5OptimizationNativeApiTest.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_create_config;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_create_opt_env;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_destroy_config;
import org.junit.AssumptionViolatedException;
import org.junit.Before;
import org.junit.BeforeClass;
import org.sosy_lab.common.NativeLibraries;
public class Mathsat5OptimizationNativeApiTest extends Mathsat5AbstractNativeApiTest {
@BeforeClass
public static void loadMathsat() {
try {
NativeLibraries.loadLibrary("optimathsat5j");
} catch (UnsatisfiedLinkError e) {
throw new AssumptionViolatedException("OptiMathSAT5 is not available", e);
}
}
@Before
public void createEnvironment() {
long cfg = msat_create_config();
env = msat_create_opt_env(cfg);
msat_destroy_config(cfg);
}
}
| 1,199 | 30.578947 | 91 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5OptimizationProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5FormulaManager.getMsatTerm;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.MSAT_OPTIMUM;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_assert_formula;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_assert_objective;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_check_sat;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_load_objective_model;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_maximize;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_minimize;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_number;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_objective_value_is_unbounded;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_objective_value_term;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_pop_backtrack_point;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_push_backtrack_point;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_term_repr;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Map;
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.common.UniqueIdGenerator;
import org.sosy_lab.common.collect.PathCopyingPersistentTreeMap;
import org.sosy_lab.common.collect.PersistentMap;
import org.sosy_lab.common.rationals.Rational;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.Model;
import org.sosy_lab.java_smt.api.OptimizationProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
class Mathsat5OptimizationProver extends Mathsat5AbstractProver<Void>
implements OptimizationProverEnvironment {
private static final int ERROR_TERM = 0;
private final UniqueIdGenerator idGenerator = new UniqueIdGenerator();
/**
* ID given to user -> number of the objective. Size corresponds to the number of currently
* existing objectives.
*/
private PersistentMap<Integer, Long> objectiveMap = PathCopyingPersistentTreeMap.of();
/** Stack of the objective maps. Some duplication, but shouldn't be too important. */
private final Deque<PersistentMap<Integer, Long>> stack = new ArrayDeque<>();
Mathsat5OptimizationProver(
Mathsat5SolverContext pMgr,
ShutdownNotifier pShutdownNotifier,
Mathsat5FormulaCreator creator,
Set<ProverOptions> options) {
super(pMgr, options, creator, pShutdownNotifier);
}
@Override
protected void createConfig(Map<String, String> pConfig) {
pConfig.put("model_generation", "true");
}
@Override
@Nullable
public Void addConstraint(BooleanFormula constraint) {
msat_assert_formula(curEnv, getMsatTerm(constraint));
return null;
}
@Override
public int maximize(Formula objective) {
long objectiveId = msat_make_maximize(curEnv, getMsatTerm(objective));
msat_assert_objective(curEnv, objectiveId);
int id = idGenerator.getFreshId(); // mapping needed to avoid long-int-conversion
objectiveMap = objectiveMap.putAndCopy(id, objectiveId);
return id;
}
@Override
public int minimize(Formula objective) {
long objectiveId = msat_make_minimize(curEnv, getMsatTerm(objective));
msat_assert_objective(curEnv, objectiveId);
int id = idGenerator.getFreshId(); // mapping needed to avoid long-int-conversion
objectiveMap = objectiveMap.putAndCopy(id, objectiveId);
return id;
}
@Override
public OptStatus check() throws InterruptedException, SolverException {
final boolean isSatisfiable = msat_check_sat(curEnv);
if (isSatisfiable) {
return OptStatus.OPT;
} else {
return OptStatus.UNSAT;
}
}
@Override
public void push() {
msat_push_backtrack_point(curEnv);
stack.add(objectiveMap);
}
@Override
public void pop() {
msat_pop_backtrack_point(curEnv);
objectiveMap = stack.pop();
}
@Override
public Optional<Rational> upper(int handle, Rational epsilon) {
return getValue(handle, epsilon);
}
@Override
public Optional<Rational> lower(int handle, Rational epsilon) {
return getValue(handle, epsilon);
}
private Optional<Rational> getValue(int handle, Rational epsilon) {
assert objectiveMap.containsKey(handle) : "querying an unknown handle";
long objective = objectiveMap.get(handle);
int isUnbounded = msat_objective_value_is_unbounded(curEnv, objective, MSAT_OPTIMUM);
if (isUnbounded == 1) {
return Optional.empty();
}
assert isUnbounded == 0;
long epsilonTerm = msat_make_number(curEnv, epsilon.toString());
long objectiveValue =
msat_objective_value_term(curEnv, objective, MSAT_OPTIMUM, ERROR_TERM, epsilonTerm);
return Optional.of(Rational.ofString(msat_term_repr(objectiveValue)));
}
@Override
public Model getModel() throws SolverException {
if (!objectiveMap.isEmpty()) {
msat_load_objective_model(curEnv, objectiveMap.values().iterator().next());
}
return super.getModel();
}
}
| 5,752 | 37.099338 | 105 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5RationalFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_make_divide;
import java.math.BigDecimal;
import org.sosy_lab.java_smt.api.NumeralFormula;
import org.sosy_lab.java_smt.api.NumeralFormula.RationalFormula;
import org.sosy_lab.java_smt.api.RationalFormulaManager;
class Mathsat5RationalFormulaManager
extends Mathsat5NumeralFormulaManager<NumeralFormula, RationalFormula>
implements RationalFormulaManager {
Mathsat5RationalFormulaManager(
Mathsat5FormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
}
@Override
protected long getNumeralType() {
return getFormulaCreator().getRationalType();
}
@Override
protected Long makeNumberImpl(double pNumber) {
return makeNumberImpl(Double.toString(pNumber));
}
@Override
protected Long makeNumberImpl(BigDecimal pNumber) {
return makeNumberImpl(pNumber.toPlainString());
}
@Override
public Long divide(Long pNumber1, Long pNumber2) {
return msat_make_divide(mathsatEnv, pNumber1, pNumber2);
}
}
| 1,376 | 28.297872 | 88 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5SolverContext.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_create_config;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_create_env;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_create_opt_env;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_create_shared_env;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_create_shared_opt_env;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_destroy_config;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_destroy_env;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_get_version;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_set_option_checked;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_set_termination_callback;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.base.Splitter.MapSplitter;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.io.MoreFiles;
import java.io.IOException;
import java.nio.file.Path;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
import java.util.logging.Level;
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.common.log.LogManager;
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.AbstractNumeralFormulaManager.NonLinearArithmetic;
import org.sosy_lab.java_smt.basicimpl.AbstractSolverContext;
import org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.TerminationCallback;
public final class Mathsat5SolverContext extends AbstractSolverContext {
@Options(prefix = "solver.mathsat5")
private static class Mathsat5Settings {
@Option(
secure = true,
description =
"Further options that will be passed to Mathsat in addition to the default options. "
+ "Format is 'key1=value1,key2=value2'")
private String furtherOptions = "";
@Option(secure = true, description = "Load less stable optimizing version of mathsat5 solver.")
boolean loadOptimathsat5 = false;
private final @Nullable PathCounterTemplate logfile;
private final ImmutableMap<String, String> furtherOptionsMap;
private Mathsat5Settings(Configuration config, @Nullable PathCounterTemplate pLogfile)
throws InvalidConfigurationException {
config.inject(this);
logfile = pLogfile;
MapSplitter optionSplitter =
Splitter.on(',')
.trimResults()
.omitEmptyStrings()
.withKeyValueSeparator(Splitter.on('=').limit(2).trimResults());
try {
furtherOptionsMap = ImmutableMap.copyOf(optionSplitter.split(furtherOptions));
} catch (IllegalArgumentException e) {
throw new InvalidConfigurationException(
"Invalid Mathsat option in \"" + furtherOptions + "\": " + e.getMessage(), e);
}
}
}
private static final boolean USE_SHARED_ENV = true;
private static final boolean USE_GHOST_FILTER = true;
private final LogManager logger;
private final long mathsatConfig;
private final Mathsat5Settings settings;
private final long randomSeed;
private final ShutdownNotifier shutdownNotifier;
private final TerminationCallback terminationTest;
private final Mathsat5FormulaCreator creator;
private boolean closed = false;
private static boolean loaded = false;
@SuppressWarnings("checkstyle:parameternumber")
private Mathsat5SolverContext(
LogManager logger,
long mathsatConfig,
Mathsat5Settings settings,
long randomSeed,
final ShutdownNotifier shutdownNotifier,
Mathsat5FormulaManager manager,
Mathsat5FormulaCreator creator) {
super(manager);
logLicenseInfo(logger);
this.logger = logger;
this.mathsatConfig = mathsatConfig;
this.settings = settings;
this.randomSeed = randomSeed;
this.shutdownNotifier = shutdownNotifier;
this.creator = creator;
terminationTest =
() -> {
shutdownNotifier.shutdownIfNecessary();
return false;
};
}
private static void logLicenseInfo(LogManager logger) {
if (!loaded) { // Avoid logging twice.
loaded = true;
logger.log(
Level.WARNING,
"MathSAT5 is available for research and evaluation purposes only. It can not be used in"
+ " a commercial environment, particularly as part of a commercial product, without "
+ "written permission. MathSAT5 is provided as is, without any warranty. "
+ "Please write to [email protected] for additional questions regarding licensing "
+ "MathSAT5 or obtaining more up-to-date versions.");
}
}
@SuppressWarnings("ParameterNumber")
public static Mathsat5SolverContext create(
LogManager logger,
Configuration config,
ShutdownNotifier pShutdownNotifier,
@Nullable PathCounterTemplate solverLogFile,
long randomSeed,
FloatingPointRoundingMode pFloatingPointRoundingMode,
NonLinearArithmetic pNonLinearArithmetic,
Consumer<String> pLoader)
throws InvalidConfigurationException {
// Init Msat
Mathsat5Settings settings = new Mathsat5Settings(config, solverLogFile);
if (settings.loadOptimathsat5) {
pLoader.accept("optimathsat5j");
} else {
loadLibrary(pLoader);
}
long msatConf = msat_create_config();
msat_set_option_checked(msatConf, "theory.la.split_rat_eq", "false");
msat_set_option_checked(msatConf, "random_seed", Long.toString(randomSeed));
for (Map.Entry<String, String> option : settings.furtherOptionsMap.entrySet()) {
try {
msat_set_option_checked(msatConf, option.getKey(), option.getValue());
} catch (IllegalArgumentException e) {
throw new InvalidConfigurationException(e.getMessage(), e);
}
}
final long msatEnv;
if (settings.loadOptimathsat5) {
msatEnv = msat_create_opt_env(msatConf);
} else {
msatEnv = msat_create_env(msatConf);
}
// Create Mathsat5FormulaCreator
Mathsat5FormulaCreator creator = new Mathsat5FormulaCreator(msatEnv);
// Create managers
Mathsat5UFManager functionTheory = new Mathsat5UFManager(creator);
Mathsat5BooleanFormulaManager booleanTheory = new Mathsat5BooleanFormulaManager(creator);
Mathsat5IntegerFormulaManager integerTheory =
new Mathsat5IntegerFormulaManager(creator, pNonLinearArithmetic);
Mathsat5RationalFormulaManager rationalTheory =
new Mathsat5RationalFormulaManager(creator, pNonLinearArithmetic);
Mathsat5BitvectorFormulaManager bitvectorTheory =
new Mathsat5BitvectorFormulaManager(creator, booleanTheory);
Mathsat5FloatingPointFormulaManager floatingPointTheory =
new Mathsat5FloatingPointFormulaManager(creator, pFloatingPointRoundingMode);
Mathsat5ArrayFormulaManager arrayTheory = new Mathsat5ArrayFormulaManager(creator);
Mathsat5EnumerationFormulaManager enumerationTheory =
new Mathsat5EnumerationFormulaManager(creator);
Mathsat5FormulaManager manager =
new Mathsat5FormulaManager(
creator,
functionTheory,
booleanTheory,
integerTheory,
rationalTheory,
bitvectorTheory,
floatingPointTheory,
arrayTheory,
enumerationTheory);
return new Mathsat5SolverContext(
logger, msatConf, settings, randomSeed, pShutdownNotifier, manager, creator);
}
@VisibleForTesting
static void loadLibrary(Consumer<String> pLoader) {
loadLibrariesWithFallback(
pLoader, ImmutableList.of("mathsat5j"), ImmutableList.of("mpir", "mathsat", "mathsat5j"));
}
long createEnvironment(long cfg) {
if (USE_GHOST_FILTER) {
msat_set_option_checked(cfg, "dpll.ghost_filtering", "true");
}
msat_set_option_checked(cfg, "theory.la.split_rat_eq", "false");
msat_set_option_checked(cfg, "random_seed", Long.toString(randomSeed));
for (Map.Entry<String, String> option : settings.furtherOptionsMap.entrySet()) {
msat_set_option_checked(cfg, option.getKey(), option.getValue());
}
if (settings.logfile != null) {
Path filename = settings.logfile.getFreshPath();
try {
MoreFiles.createParentDirectories(filename);
} catch (IOException e) {
logger.logUserException(Level.WARNING, e, "Cannot create directory for MathSAT logfile");
}
msat_set_option_checked(cfg, "debug.api_call_trace", "1");
msat_set_option_checked(
cfg, "debug.api_call_trace_filename", filename.toAbsolutePath().toString());
}
final long env;
if (USE_SHARED_ENV) {
if (settings.loadOptimathsat5) {
env = msat_create_shared_opt_env(cfg, creator.getEnv());
} else {
env = msat_create_shared_env(cfg, creator.getEnv());
}
} else {
if (settings.loadOptimathsat5) {
env = msat_create_opt_env(cfg);
} else {
env = msat_create_env(cfg);
}
}
return env;
}
@Override
protected ProverEnvironment newProverEnvironment0(Set<ProverOptions> options) {
Preconditions.checkState(!closed, "solver context is already closed");
return new Mathsat5TheoremProver(this, shutdownNotifier, creator, options);
}
@Override
protected InterpolatingProverEnvironment<?> newProverEnvironmentWithInterpolation0(
Set<ProverOptions> options) {
Preconditions.checkState(!closed, "solver context is already closed");
return new Mathsat5InterpolatingProver(this, shutdownNotifier, creator, options);
}
@Override
public OptimizationProverEnvironment newOptimizationProverEnvironment0(
Set<ProverOptions> options) {
Preconditions.checkState(!closed, "solver context is already closed");
return new Mathsat5OptimizationProver(this, shutdownNotifier, creator, options);
}
@Override
public String getVersion() {
return msat_get_version();
}
@Override
public Solvers getSolverName() {
return Solvers.MATHSAT5;
}
@Override
public void close() {
if (!closed) {
closed = true;
logger.log(Level.FINER, "Freeing Mathsat environment");
msat_destroy_env(creator.getEnv());
msat_destroy_config(mathsatConfig);
}
}
long addTerminationTest(long env) {
Preconditions.checkState(!closed, "solver context is already closed");
return msat_set_termination_callback(env, terminationTest);
}
@Override
protected boolean supportsAssumptionSolving() {
return true;
}
}
| 11,731 | 36.482428 | 101 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5TheoremProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5FormulaManager.getMsatTerm;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_assert_formula;
import static org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5NativeApi.msat_push_backtrack_point;
import com.google.common.base.Preconditions;
import java.util.Map;
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.ProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
class Mathsat5TheoremProver extends Mathsat5AbstractProver<Void> implements ProverEnvironment {
Mathsat5TheoremProver(
Mathsat5SolverContext pMgr,
ShutdownNotifier pShutdownNotifier,
Mathsat5FormulaCreator creator,
Set<ProverOptions> options) {
super(pMgr, options, creator, pShutdownNotifier);
}
@Override
protected void createConfig(Map<String, String> pConfig) {
// nothing to do
}
@Override
@Nullable
public Void addConstraint(BooleanFormula constraint) {
Preconditions.checkState(!closed);
closeAllEvaluators();
msat_assert_formula(curEnv, getMsatTerm(constraint));
return null;
}
@Override
public void push() {
Preconditions.checkState(!closed);
msat_push_backtrack_point(curEnv);
}
}
| 1,702 | 30.537037 | 97 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/Mathsat5UFManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.mathsat5;
import org.sosy_lab.java_smt.basicimpl.AbstractUFManager;
class Mathsat5UFManager extends AbstractUFManager<Long, Long, Long, Long> {
Mathsat5UFManager(Mathsat5FormulaCreator pCreator) {
super(pCreator);
}
}
| 507 | 25.736842 | 75 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/mathsat5/package-info.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
/** Interface to the SMT solver MathSAT5 (based on the native 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.mathsat5;
| 593 | 38.6 | 80 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessAbstractProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import static com.google.common.base.Preconditions.checkNotNull;
import static scala.collection.JavaConverters.asJava;
import static scala.collection.JavaConverters.asScala;
import ap.api.PartialModel;
import ap.api.SimpleAPI;
import ap.api.SimpleAPI.SimpleAPIException;
import ap.parser.IExpression;
import ap.parser.IFormula;
import ap.parser.IFunction;
import ap.parser.ITerm;
import com.google.common.base.Preconditions;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Deque;
import java.util.List;
import java.util.Optional;
import java.util.Set;
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.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 scala.Enumeration.Value;
@SuppressWarnings("ClassTypeParameterName")
abstract class PrincessAbstractProver<E, AF> extends AbstractProverWithAllSat<E> {
protected final SimpleAPI api;
protected final PrincessFormulaManager mgr;
protected final Deque<List<AF>> assertedFormulas = new ArrayDeque<>(); // all terms on all levels
private final Deque<Level> trackingStack = new ArrayDeque<>(); // symbols on all levels
private final PrincessFormulaCreator creator;
protected boolean wasLastSatCheckSat = false; // and stack is not changed
protected PrincessAbstractProver(
PrincessFormulaManager pMgr,
PrincessFormulaCreator creator,
SimpleAPI pApi,
ShutdownNotifier pShutdownNotifier,
Set<ProverOptions> pOptions) {
super(pOptions, pMgr.getBooleanFormulaManager(), pShutdownNotifier);
this.mgr = pMgr;
this.creator = creator;
this.api = checkNotNull(pApi);
assertedFormulas.push(new ArrayList<>());
trackingStack.push(new Level(0));
}
/**
* This function causes the SatSolver to check all the terms on the stack, if their conjunction is
* SAT or UNSAT.
*/
@Override
public boolean isUnsat() throws SolverException {
Preconditions.checkState(!closed);
wasLastSatCheckSat = false;
final Value result = api.checkSat(true);
if (result.equals(SimpleAPI.ProverStatus$.MODULE$.Sat())) {
wasLastSatCheckSat = true;
return false;
} else if (result.equals(SimpleAPI.ProverStatus$.MODULE$.Unsat())) {
return true;
} else if (result.equals(SimpleAPI.ProverStatus$.MODULE$.OutOfMemory())) {
throw new SolverException(
"Princess ran out of stack or heap memory, try increasing their sizes.");
} else {
throw new SolverException("Princess' checkSat call returned " + result);
}
}
protected void addConstraint0(IFormula t) {
Preconditions.checkState(!closed);
wasLastSatCheckSat = false;
api.addAssertion(api.abbrevSharedExpressions(t, creator.getEnv().getMinAtomsForAbbreviation()));
}
protected int addAssertedFormula(AF f) {
assertedFormulas.peek().add(f);
final int id = trackingStack.peek().constraintNum++;
return id;
}
@Override
public final void push() {
Preconditions.checkState(!closed);
wasLastSatCheckSat = false;
assertedFormulas.push(new ArrayList<>());
api.push();
final int oldConstraintNum;
if (trackingStack.isEmpty()) {
oldConstraintNum = 0;
} else {
oldConstraintNum = trackingStack.peek().constraintNum;
}
trackingStack.push(new Level(oldConstraintNum));
}
@Override
public void pop() {
Preconditions.checkState(!closed);
Preconditions.checkState(size() > 0);
wasLastSatCheckSat = false;
assertedFormulas.pop();
api.pop();
// we have to recreate symbols on lower levels, because JavaSMT assumes "global" symbols.
Level level = trackingStack.pop();
api.addBooleanVariables(asScala(level.booleanSymbols));
api.addConstants(asScala(level.intSymbols));
level.functionSymbols.forEach(api::addFunction);
if (!trackingStack.isEmpty()) {
trackingStack.peek().mergeWithHigher(level);
}
}
@Override
public int size() {
Preconditions.checkState(!closed);
return assertedFormulas.size() - 1;
}
@SuppressWarnings("resource")
@Override
public Model getModel() throws SolverException {
Preconditions.checkState(!closed);
Preconditions.checkState(wasLastSatCheckSat, NO_MODEL_HELP);
checkGenerateModels();
return new CachingModel(getEvaluatorWithoutChecks());
}
@Override
protected PrincessModel getEvaluatorWithoutChecks() throws SolverException {
final PartialModel partialModel;
try {
partialModel = partialModel();
} catch (SimpleAPIException ex) {
throw new SolverException(ex.getMessage(), ex);
}
return new PrincessModel(this, partialModel, creator, api);
}
/**
* This method only exists to allow catching the exception from Scala in Java.
*
* @throws SimpleAPIException if model can not be constructed.
*/
private PartialModel partialModel() throws SimpleAPIException {
return api.partialModel();
}
@Override
public boolean isUnsatWithAssumptions(Collection<BooleanFormula> pAssumptions)
throws SolverException, InterruptedException {
throw new UnsupportedOperationException("Solving with assumptions is not supported.");
}
@Override
public List<BooleanFormula> getUnsatCore() {
Preconditions.checkState(!closed);
checkGenerateUnsatCores();
final List<BooleanFormula> result = new ArrayList<>();
final Set<Object> core = asJava(api.getUnsatCore());
int cnt = 0;
for (IExpression formula : getAssertedFormulas()) {
if (core.contains(cnt)) {
result.add(mgr.encapsulateBooleanFormula(formula));
}
++cnt;
}
return result;
}
protected abstract Iterable<IExpression> getAssertedFormulas();
@Override
public Optional<List<BooleanFormula>> unsatCoreOverAssumptions(
Collection<BooleanFormula> assumptions) {
throw new UnsupportedOperationException(
"UNSAT cores over assumptions not supported by Princess");
}
@Override
public void close() {
checkNotNull(api);
checkNotNull(mgr);
if (!closed) {
api.shutDown();
api.reset(); // cleanup memory, even if we keep a reference to "api" and "mgr"
creator.getEnv().unregisterStack(this);
}
closed = true;
}
@Override
public <T> T allSat(AllSatCallback<T> callback, List<BooleanFormula> important)
throws InterruptedException, SolverException {
T result = super.allSat(callback, important);
wasLastSatCheckSat = false; // we do not know about the current state, thus we reset the flag.
return result;
}
/** add external definition: boolean variable. */
void addSymbol(IFormula f) {
Preconditions.checkState(!closed);
api.addBooleanVariable(f);
if (!trackingStack.isEmpty()) {
trackingStack.peek().booleanSymbols.add(f);
}
}
/** add external definition: integer variable. */
void addSymbol(ITerm f) {
Preconditions.checkState(!closed);
api.addConstant(f);
if (!trackingStack.isEmpty()) {
trackingStack.peek().intSymbols.add(f);
}
}
/** add external definition: uninterpreted function. */
void addSymbol(IFunction f) {
Preconditions.checkState(!closed);
api.addFunction(f);
if (!trackingStack.isEmpty()) {
trackingStack.peek().functionSymbols.add(f);
}
}
private static class Level {
final List<IFormula> booleanSymbols = new ArrayList<>();
final List<ITerm> intSymbols = new ArrayList<>();
final List<IFunction> functionSymbols = new ArrayList<>();
// the number of constraints asserted up to this point, this is needed
// for unsat core computation
int constraintNum;
Level(int constraintNum) {
this.constraintNum = constraintNum;
}
/** add higher level to current level, we keep the order of creating symbols. */
void mergeWithHigher(Level other) {
this.booleanSymbols.addAll(other.booleanSymbols);
this.intSymbols.addAll(other.intSymbols);
this.functionSymbols.addAll(other.functionSymbols);
}
@Override
public String toString() {
return String.format("{%s, %s, %s}", booleanSymbols, intSymbols, functionSymbols);
}
}
}
| 8,696 | 30.974265 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessArrayFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import ap.parser.IExpression;
import ap.parser.ITerm;
import ap.types.Sort;
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;
import org.sosy_lab.java_smt.basicimpl.FormulaCreator;
class PrincessArrayFormulaManager
extends AbstractArrayFormulaManager<
IExpression, Sort, PrincessEnvironment, PrincessFunctionDeclaration> {
private final PrincessEnvironment env;
PrincessArrayFormulaManager(
FormulaCreator<IExpression, Sort, PrincessEnvironment, PrincessFunctionDeclaration>
pFormulaCreator) {
super(pFormulaCreator);
env = pFormulaCreator.getEnv();
}
@Override
protected IExpression select(IExpression pArray, IExpression pIndex) {
return env.makeSelect((ITerm) pArray, (ITerm) pIndex);
}
@Override
protected IExpression store(IExpression pArray, IExpression pIndex, IExpression pValue) {
return env.makeStore((ITerm) pArray, (ITerm) pIndex, (ITerm) pValue);
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TI extends Formula, TE extends Formula> IExpression internalMakeArray(
String pName, FormulaType<TI> pIndexType, FormulaType<TE> pElementType) {
final ArrayFormulaType<TI, TE> arrayFormulaType =
FormulaType.getArrayType(pIndexType, pElementType);
final Sort arrayType = toSolverType(arrayFormulaType);
return getFormulaCreator().makeVariable(arrayType, pName);
}
@Override
protected IExpression equivalence(IExpression pArray1, IExpression pArray2) {
return ap.parser.IExpression.Eq$.MODULE$.apply((ITerm) pArray1, (ITerm) pArray2);
}
}
| 2,037 | 33.542373 | 91 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessBitvectorFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import ap.basetypes.IdealInt;
import ap.parser.IExpression;
import ap.parser.ITerm;
import ap.theories.bitvectors.ModuloArithmetic$;
import ap.types.Sort;
import ap.types.Sort$;
import com.google.common.base.Preconditions;
import java.math.BigInteger;
import org.sosy_lab.java_smt.basicimpl.AbstractBitvectorFormulaManager;
import scala.Option;
class PrincessBitvectorFormulaManager
extends AbstractBitvectorFormulaManager<
IExpression, Sort, PrincessEnvironment, PrincessFunctionDeclaration> {
PrincessBitvectorFormulaManager(
PrincessFormulaCreator pCreator, PrincessBooleanFormulaManager pBmgr) {
super(pCreator, pBmgr);
}
@Override
protected IExpression negate(IExpression pParam1) {
return ModuloArithmetic$.MODULE$.bvneg((ITerm) pParam1);
}
@Override
protected IExpression add(IExpression pParam1, IExpression pParam2) {
return ModuloArithmetic$.MODULE$.bvadd((ITerm) pParam1, (ITerm) pParam2);
}
@Override
protected IExpression subtract(IExpression pParam1, IExpression pParam2) {
return ModuloArithmetic$.MODULE$.bvsub((ITerm) pParam1, (ITerm) pParam2);
}
@Override
protected IExpression divide(IExpression pParam1, IExpression pParam2, boolean signed) {
if (signed) {
return ModuloArithmetic$.MODULE$.bvsdiv((ITerm) pParam1, (ITerm) pParam2);
} else {
return ModuloArithmetic$.MODULE$.bvudiv((ITerm) pParam1, (ITerm) pParam2);
}
}
@Override
protected IExpression modulo(IExpression pParam1, IExpression pParam2, boolean signed) {
if (signed) {
return ModuloArithmetic$.MODULE$.bvsrem((ITerm) pParam1, (ITerm) pParam2);
} else {
return ModuloArithmetic$.MODULE$.bvurem((ITerm) pParam1, (ITerm) pParam2);
}
}
@Override
protected IExpression multiply(IExpression pParam1, IExpression pParam2) {
return ModuloArithmetic$.MODULE$.bvmul((ITerm) pParam1, (ITerm) pParam2);
}
@Override
protected IExpression equal(IExpression pParam1, IExpression pParam2) {
return ((ITerm) pParam1).$eq$eq$eq((ITerm) pParam2);
}
@Override
protected IExpression greaterThan(IExpression pParam1, IExpression pParam2, boolean signed) {
return lessThan(pParam2, pParam1, signed);
}
@Override
protected IExpression greaterOrEquals(IExpression pParam1, IExpression pParam2, boolean signed) {
return lessOrEquals(pParam2, pParam1, signed);
}
@Override
protected IExpression lessThan(IExpression pParam1, IExpression pParam2, boolean signed) {
if (signed) {
return ModuloArithmetic$.MODULE$.bvslt((ITerm) pParam1, (ITerm) pParam2);
} else {
return ModuloArithmetic$.MODULE$.bvult((ITerm) pParam1, (ITerm) pParam2);
}
}
@Override
protected IExpression lessOrEquals(IExpression pParam1, IExpression pParam2, boolean signed) {
if (signed) {
return ModuloArithmetic$.MODULE$.bvsle((ITerm) pParam1, (ITerm) pParam2);
} else {
return ModuloArithmetic$.MODULE$.bvule((ITerm) pParam1, (ITerm) pParam2);
}
}
@Override
protected IExpression not(IExpression pParam1) {
return ModuloArithmetic$.MODULE$.bvnot((ITerm) pParam1);
}
@Override
protected IExpression and(IExpression pParam1, IExpression pParam2) {
return ModuloArithmetic$.MODULE$.bvand((ITerm) pParam1, (ITerm) pParam2);
}
@Override
protected IExpression or(IExpression pParam1, IExpression pParam2) {
return ModuloArithmetic$.MODULE$.bvor((ITerm) pParam1, (ITerm) pParam2);
}
@Override
protected IExpression xor(IExpression pParam1, IExpression pParam2) {
return ModuloArithmetic$.MODULE$.bvxor((ITerm) pParam1, (ITerm) pParam2);
}
@Override
protected IExpression makeBitvectorImpl(int pLength, BigInteger pI) {
pI = transformValueToRange(pLength, pI);
return ModuloArithmetic$.MODULE$.bv(pLength, IdealInt.apply(pI));
}
@Override
protected IExpression makeBitvectorImpl(int pLength, IExpression pIntegerFormula) {
return ModuloArithmetic$.MODULE$.cast2UnsignedBV(pLength, (ITerm) pIntegerFormula);
}
@Override
protected IExpression toIntegerFormulaImpl(IExpression pBVFormula, boolean signed) {
final Sort sort = Sort$.MODULE$.sortOf((ITerm) pBVFormula);
final Option<Object> bitWidth = PrincessEnvironment.getBitWidth(sort);
Preconditions.checkArgument(bitWidth.isDefined());
final int size = (Integer) bitWidth.get();
// compute range for integer value,
// example: bitWidth=4 => signed_range=[-8;7] and unsigned_range=[0;15]
final BigInteger min;
final BigInteger max;
if (signed) {
min = BigInteger.ONE.shiftLeft(size - 1).negate();
max = BigInteger.ONE.shiftLeft(size - 1).subtract(BigInteger.ONE);
} else {
min = BigInteger.ZERO;
max = BigInteger.ONE.shiftLeft(size).subtract(BigInteger.ONE);
}
ITerm bvInRange =
ModuloArithmetic$.MODULE$.cast2Interval(
IdealInt.apply(min), IdealInt.apply(max), (ITerm) pBVFormula);
// Princess can not directly convert from BV to INT. However, adding zero helps. Ugly.
return IExpression.i(0).$plus(bvInRange);
}
@Override
protected IExpression makeVariableImpl(int pLength, String pVar) {
Sort t = getFormulaCreator().getBitvectorType(pLength);
return getFormulaCreator().makeVariable(t, pVar);
}
@Override
protected IExpression shiftRight(IExpression pNumber, IExpression toShift, boolean signed) {
if (signed) {
return ModuloArithmetic$.MODULE$.bvashr((ITerm) pNumber, (ITerm) toShift);
} else {
return ModuloArithmetic$.MODULE$.bvlshr((ITerm) pNumber, (ITerm) toShift);
}
}
@Override
protected IExpression shiftLeft(IExpression pExtract, IExpression pExtract2) {
return ModuloArithmetic$.MODULE$.bvshl((ITerm) pExtract, (ITerm) pExtract2);
}
@Override
protected IExpression concat(IExpression number, IExpression pAppend) {
return ModuloArithmetic$.MODULE$.concat((ITerm) number, (ITerm) pAppend);
}
@Override
protected IExpression extract(IExpression pNumber, int pMsb, int pLsb) {
return ModuloArithmetic$.MODULE$.extract(pMsb, pLsb, (ITerm) pNumber);
}
@Override
protected IExpression extend(IExpression pNumber, int pExtensionBits, boolean pSigned) {
if (pSigned) {
return ModuloArithmetic$.MODULE$.sign_extend(pExtensionBits, (ITerm) pNumber);
} else {
return ModuloArithmetic$.MODULE$.zero_extend(pExtensionBits, (ITerm) pNumber);
}
}
}
| 6,725 | 32.798995 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessBooleanFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import ap.parser.IBinFormula;
import ap.parser.IBinJunctor;
import ap.parser.IBoolLit;
import ap.parser.IExpression;
import ap.parser.IFormula;
import ap.parser.IFormulaITE;
import ap.parser.INot;
import ap.parser.ITerm;
import ap.parser.ITermITE;
import ap.types.Sort;
import org.sosy_lab.java_smt.basicimpl.AbstractBooleanFormulaManager;
import scala.Enumeration;
class PrincessBooleanFormulaManager
extends AbstractBooleanFormulaManager<
IExpression, Sort, PrincessEnvironment, PrincessFunctionDeclaration> {
private final IBoolLit pTrue = new IBoolLit(true);
private final IBoolLit pFalse = new IBoolLit(false);
PrincessBooleanFormulaManager(PrincessFormulaCreator creator) {
super(creator);
}
@Override
public IFormula makeVariableImpl(String varName) {
return (IFormula) getFormulaCreator().makeVariable(getFormulaCreator().getBoolType(), varName);
}
@Override
public IFormula makeBooleanImpl(boolean pValue) {
return pValue ? pTrue : pFalse;
}
@Override
public IFormula equivalence(IExpression t1, IExpression t2) {
return new IBinFormula(IBinJunctor.Eqv(), (IFormula) t1, (IFormula) t2);
}
@Override
public boolean isTrue(IExpression t) {
return t instanceof IBoolLit && ((IBoolLit) t).value();
}
@Override
public boolean isFalse(IExpression t) {
return t instanceof IBoolLit && !((IBoolLit) t).value();
}
@Override
public IExpression ifThenElse(IExpression condition, IExpression t1, IExpression t2) {
if (isTrue(condition)) {
return t1;
} else if (isFalse(condition)) {
return t2;
} else if (t1.equals(t2)) {
return t1;
} else if (isTrue(t1) && isFalse(t2)) {
return condition;
} else if (isFalse(t1) && isTrue(t2)) {
return not(condition);
}
if (t1 instanceof IFormula) {
return new IFormulaITE((IFormula) condition, (IFormula) t1, (IFormula) t2);
} else {
return new ITermITE((IFormula) condition, (ITerm) t1, (ITerm) t2);
}
}
@Override
public IFormula not(IExpression pBits) {
if (isTrue(pBits)) {
return pFalse;
} else if (isFalse(pBits)) {
return pTrue;
} else if (pBits instanceof INot) {
return ((INot) pBits).subformula(); // "not not a" == "a"
} else {
return new INot((IFormula) pBits);
}
}
@Override
public IFormula and(IExpression t1, IExpression t2) {
if (t1 == t2) {
return (IFormula) t1;
} else if (isTrue(t1)) {
return (IFormula) t2;
} else if (isTrue(t2)) {
return (IFormula) t1;
} else if (isFalse(t1)) {
return pFalse;
} else if (isFalse(t2)) {
return pFalse;
}
return simplify(new IBinFormula(IBinJunctor.And(), (IFormula) t1, (IFormula) t2));
}
@Override
public IFormula or(IExpression t1, IExpression t2) {
if (t1 == t2) {
return (IFormula) t1;
} else if (isTrue(t1)) {
return pTrue;
} else if (isTrue(t2)) {
return pTrue;
} else if (isFalse(t1)) {
return (IFormula) t2;
} else if (isFalse(t2)) {
return (IFormula) t1;
}
return simplify(new IBinFormula(IBinJunctor.Or(), (IFormula) t1, (IFormula) t2));
}
/**
* simplification based on distribution property of boolean operands, to avoid identical subgraphs
* in basic boolean operations:
*
* <ul>
* <li>(a&b)&(a&c) --> a&(b&c)
* <li>(a|b)&(a|c) --> a|(b&c)
* <li>(a&b)|(a&c) --> a&(b|c)
* <li>(a|b)|(a|c) --> a|(b|c)
* </ul>
*
* <p>Note that we only consider the most frequently used operations here. There are more
* combination of boolean operators (implication and equivalence), which are ignored here, to keep
* it simple.
*/
private IFormula simplify(IFormula f) {
if (f instanceof IBinFormula) {
final IBinFormula bin = (IBinFormula) f;
Enumeration.Value operator = bin.j();
if (isDistributiveBooleanOperator(operator)
&& bin.f1() instanceof IBinFormula
&& bin.f2() instanceof IBinFormula
&& ((IBinFormula) bin.f1()).j().equals(((IBinFormula) bin.f2()).j())) {
Enumeration.Value innerOperator = ((IBinFormula) bin.f1()).j();
if (isDistributiveBooleanOperator(innerOperator)) {
IFormula s11 = ((IBinFormula) bin.f1()).f1();
IFormula s12 = ((IBinFormula) bin.f1()).f2();
IFormula s21 = ((IBinFormula) bin.f2()).f1();
IFormula s22 = ((IBinFormula) bin.f2()).f2();
// only check for object equality, for performance
if (s11 == s21) { // (ab)(ac) -> a(bc)
return new IBinFormula(innerOperator, s11, new IBinFormula(operator, s12, s22));
} else if (s11 == s22) { // (ab)(ca) -> a(bc)
return new IBinFormula(innerOperator, s11, new IBinFormula(operator, s12, s21));
} else if (s12 == s21) { // (ba)(ac) -> a(bc)
return new IBinFormula(innerOperator, s12, new IBinFormula(operator, s11, s22));
} else if (s12 == s22) { // (ba)(ca) -> a(bc)
return new IBinFormula(innerOperator, s12, new IBinFormula(operator, s11, s21));
}
}
}
}
// if we cannot simplify the formula, we create an abbreviation
// return getFormulaCreator().getEnv().abbrev(f);
return f;
}
private boolean isDistributiveBooleanOperator(Enumeration.Value operator) {
return IBinJunctor.And().equals(operator) || IBinJunctor.Or().equals(operator);
}
/**
* {@inheritDoc}
*
* <p>Princess does not support XOR Formulas are converted from {@code a^b} to {@code !(a<=>b)}
*/
@Override
public IFormula xor(IExpression t1, IExpression t2) {
return new INot(new IBinFormula(IBinJunctor.Eqv(), (IFormula) t1, (IFormula) t2));
}
}
| 6,041 | 30.968254 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessEnvironment.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import static scala.collection.JavaConverters.asJava;
import static scala.collection.JavaConverters.collectionAsScalaIterableConverter;
import ap.api.SimpleAPI;
import ap.parser.BooleanCompactifier;
import ap.parser.Environment.EnvironmentException;
import ap.parser.IAtom;
import ap.parser.IConstant;
import ap.parser.IExpression;
import ap.parser.IFormula;
import ap.parser.IFunApp;
import ap.parser.IFunction;
import ap.parser.IIntFormula;
import ap.parser.ITerm;
import ap.parser.Parser2InputAbsy.TranslationException;
import ap.parser.PartialEvaluator;
import ap.parser.SMTLineariser;
import ap.parser.SMTParser2InputAbsy.SMTFunctionType;
import ap.parser.SMTParser2InputAbsy.SMTType;
import ap.terfor.ConstantTerm;
import ap.terfor.preds.Predicate;
import ap.theories.ExtArray;
import ap.theories.bitvectors.ModuloArithmetic;
import ap.theories.rationals.Fractions.FractionSort$;
import ap.types.Sort;
import ap.types.Sort$;
import ap.types.Sort.MultipleValueBool$;
import ap.util.Debug;
import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.common.io.Files;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.nio.file.Path;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.TreeMap;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.sosy_lab.common.Appender;
import org.sosy_lab.common.Appenders;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.common.configuration.Configuration;
import org.sosy_lab.common.configuration.FileOption;
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.api.FormulaType;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import scala.Tuple2;
import scala.Tuple4;
import scala.collection.immutable.Seq;
import scala.collection.immutable.Set$;
/**
* This is a Wrapper around Princess. This Wrapper allows to set a logfile for all Smt-Queries
* (default "princess.###.smt2"). It also manages the "shared variables": each variable is declared
* for all stacks.
*/
@Options(prefix = "solver.princess")
class PrincessEnvironment {
@Option(
secure = true,
description =
"The number of atoms a term has to have before"
+ " it gets abbreviated if there are more identical terms.")
private int minAtomsForAbbreviation = 100;
@Option(
secure = true,
description =
"Enable additional assertion checks within Princess. "
+ "The main usage is debugging. This option can cause a performance overhead.")
private boolean enableAssertions = false;
public static final Sort BOOL_SORT = Sort$.MODULE$.Bool();
public static final Sort INTEGER_SORT = Sort.Integer$.MODULE$;
@Option(secure = true, description = "log all queries as Princess-specific Scala code")
private boolean logAllQueriesAsScala = false;
@Option(secure = true, description = "file for Princess-specific dump of queries as Scala code")
@FileOption(FileOption.Type.OUTPUT_FILE)
private PathCounterTemplate logAllQueriesAsScalaFile =
PathCounterTemplate.ofFormatString("princess-query-%03d-");
/**
* cache for variables, because they do not implement equals() and hashCode(), so we need to have
* the same objects.
*/
private final Map<String, IFormula> boolVariablesCache = new HashMap<>();
private final Map<String, ITerm> sortedVariablesCache = new HashMap<>();
private final Map<String, IFunction> functionsCache = new HashMap<>();
private final int randomSeed;
private final @Nullable PathCounterTemplate basicLogfile;
private final ShutdownNotifier shutdownNotifier;
/**
* The wrapped API is the first created API. It will never be used outside this class and never be
* closed. If a variable is declared, it is declared in the first api, then copied into all
* registered APIs. Each API has its own stack for formulas.
*/
private final SimpleAPI api;
private final List<PrincessAbstractProver<?, ?>> registeredProvers = new ArrayList<>();
PrincessEnvironment(
Configuration config,
@Nullable final PathCounterTemplate pBasicLogfile,
ShutdownNotifier pShutdownNotifier,
final int pRandomSeed)
throws InvalidConfigurationException {
config.inject(this);
basicLogfile = pBasicLogfile;
shutdownNotifier = pShutdownNotifier;
randomSeed = pRandomSeed;
// this api is only used local in this environment, no need for interpolation
api = getNewApi(false);
}
/**
* This method returns a new prover, that is registered in this environment. All variables are
* shared in all registered APIs.
*/
PrincessAbstractProver<?, ?> getNewProver(
boolean useForInterpolation,
PrincessFormulaManager mgr,
PrincessFormulaCreator creator,
Set<ProverOptions> pOptions) {
SimpleAPI newApi =
getNewApi(useForInterpolation || pOptions.contains(ProverOptions.GENERATE_UNSAT_CORE));
// add all symbols, that are available until now
boolVariablesCache.values().forEach(newApi::addBooleanVariable);
sortedVariablesCache.values().forEach(newApi::addConstant);
functionsCache.values().forEach(newApi::addFunction);
PrincessAbstractProver<?, ?> prover;
if (useForInterpolation) {
prover = new PrincessInterpolatingProver(mgr, creator, newApi, shutdownNotifier, pOptions);
} else {
prover = new PrincessTheoremProver(mgr, creator, newApi, shutdownNotifier, pOptions);
}
registeredProvers.add(prover);
return prover;
}
@SuppressFBWarnings("NP_NULL_ON_SOME_PATH_FROM_RETURN_VALUE")
private SimpleAPI getNewApi(boolean constructProofs) {
File directory = null;
String smtDumpBasename = null;
String scalaDumpBasename = null;
if (basicLogfile != null) {
Path logPath = basicLogfile.getFreshPath();
directory = getAbsoluteParent(logPath);
smtDumpBasename = logPath.getFileName().toString();
if (Files.getFileExtension(smtDumpBasename).equals("smt2")) {
// Princess adds .smt2 anyway
smtDumpBasename = Files.getNameWithoutExtension(smtDumpBasename);
}
smtDumpBasename += "-";
}
if (logAllQueriesAsScala && logAllQueriesAsScalaFile != null) {
Path logPath = logAllQueriesAsScalaFile.getFreshPath();
if (directory == null) {
directory = getAbsoluteParent(logPath);
}
scalaDumpBasename = logPath.getFileName().toString();
}
Debug.enableAllAssertions(enableAssertions);
final SimpleAPI newApi =
SimpleAPI.apply(
enableAssertions, // enableAssert, see above
false, // no sanitiseNames, because variable names may contain chars like "@" and ":".
smtDumpBasename != null, // dumpSMT
smtDumpBasename, // smtDumpBasename
scalaDumpBasename != null, // dumpScala
scalaDumpBasename, // scalaDumpBasename
directory, // dumpDirectory
SimpleAPI.apply$default$8(), // tightFunctionScopes
SimpleAPI.apply$default$9(), // genTotalityAxioms
new scala.Some<>(randomSeed), // randomSeed
Set$.MODULE$.empty() // empty Set<LOG_FLAG>, no internal logging
);
if (constructProofs) { // needed for interpolation and unsat cores
newApi.setConstructProofs(true);
}
return newApi;
}
private File getAbsoluteParent(Path path) {
return Optional.ofNullable(path.getParent()).orElse(Path.of(".")).toAbsolutePath().toFile();
}
int getMinAtomsForAbbreviation() {
return minAtomsForAbbreviation;
}
void unregisterStack(PrincessAbstractProver<?, ?> stack) {
Preconditions.checkState(
registeredProvers.contains(stack), "cannot unregister stack, it is not registered");
registeredProvers.remove(stack);
}
/** unregister and close all stacks. */
void close() {
for (PrincessAbstractProver<?, ?> prover : ImmutableList.copyOf(registeredProvers)) {
prover.close();
}
api.shutDown();
api.reset();
Preconditions.checkState(registeredProvers.isEmpty());
}
public List<? extends IExpression> parseStringToTerms(String s, PrincessFormulaCreator creator) {
Tuple4<
Seq<IFormula>,
scala.collection.immutable.Map<IFunction, SMTFunctionType>,
scala.collection.immutable.Map<ConstantTerm, SMTType>,
scala.collection.immutable.Map<Predicate, SMTFunctionType>>
parserResult;
try {
parserResult = extractFromSTMLIB(s);
} catch (TranslationException | EnvironmentException nested) {
throw new IllegalArgumentException(nested);
}
final List<IFormula> formulas = asJava(parserResult._1());
ImmutableSet.Builder<IExpression> declaredFunctions = ImmutableSet.builder();
for (IExpression f : formulas) {
declaredFunctions.addAll(creator.extractVariablesAndUFs(f, true).values());
}
for (IExpression var : declaredFunctions.build()) {
if (var instanceof IConstant) {
sortedVariablesCache.put(((IConstant) var).c().name(), (ITerm) var);
addSymbol((IConstant) var);
} else if (var instanceof IAtom) {
boolVariablesCache.put(((IAtom) var).pred().name(), (IFormula) var);
addSymbol((IAtom) var);
} else if (var instanceof IFunApp) {
IFunction fun = ((IFunApp) var).fun();
functionsCache.put(fun.name(), fun);
addFunction(fun);
}
}
return formulas;
}
/**
* Parse a SMTLIB query and returns a triple of the asserted formulas, the defined functions and
* symbols.
*
* @throws EnvironmentException from Princess when the parsing fails
* @throws TranslationException from Princess when the parsing fails due to type mismatch
*/
/* EnvironmentException is not unused, but the Java compiler does not like Scala. */
@SuppressWarnings("unused")
private Tuple4<
Seq<IFormula>,
scala.collection.immutable.Map<IFunction, SMTFunctionType>,
scala.collection.immutable.Map<ConstantTerm, SMTType>,
scala.collection.immutable.Map<Predicate, SMTFunctionType>>
extractFromSTMLIB(String s) throws EnvironmentException, TranslationException {
// replace let-terms and function definitions by their full term.
final boolean fullyInlineLetsAndFunctions = true;
return api.extractSMTLIBAssertionsSymbols(new StringReader(s), fullyInlineLetsAndFunctions);
}
/**
* Utility helper method to hide a checked exception as RuntimeException.
*
* <p>The generic E simulates a RuntimeException at compile time and lets us throw the correct
* Exception at run time.
*/
@SuppressWarnings("unchecked")
@SuppressFBWarnings("THROWS_METHOD_THROWS_CLAUSE_THROWABLE")
private static <E extends Throwable> void throwCheckedAsUnchecked(Throwable e) throws E {
throw (E) e;
}
/**
* This method dumps a formula as SMTLIB2.
*
* <p>We avoid redundant sub-formulas by replacing them with abbreviations. The replacement is
* done "once" when calling this method.
*
* <p>We return an {@link Appender} to avoid storing larger Strings in memory. We sort the symbols
* and abbreviations for the export only "on demand".
*/
public Appender dumpFormula(IFormula formula, final PrincessFormulaCreator creator) {
// remove redundant expressions
// TODO do we want to remove redundancy completely (as checked in the unit
// tests (SolverFormulaIOTest class)) or do we want to remove redundancy up
// to the point we do it for formulas that should be asserted
Tuple2<IExpression, scala.collection.immutable.Map<IExpression, IExpression>> tuple =
api.abbrevSharedExpressionsWithMap(formula, 1);
final IExpression lettedFormula = tuple._1();
final Map<IExpression, IExpression> abbrevMap = asJava(tuple._2());
return new Appenders.AbstractAppender() {
@Override
public void appendTo(Appendable out) throws IOException {
try {
appendTo0(out);
} catch (scala.MatchError e) {
// exception might be thrown in case of interrupt, then we wrap it in an interrupt.
if (shutdownNotifier.shouldShutdown()) {
InterruptedException interrupt = new InterruptedException();
interrupt.addSuppressed(e);
throwCheckedAsUnchecked(interrupt);
} else {
// simply re-throw exception
throw e;
}
}
}
private void appendTo0(Appendable out) throws IOException {
Set<IExpression> allVars =
new LinkedHashSet<>(creator.extractVariablesAndUFs(lettedFormula, true).values());
// We use TreeMaps for deterministic/alphabetic ordering.
// For abbreviations, we use the ordering, but dump nested abbreviations/dependencies first.
Map<String, IExpression> symbols = new TreeMap<>();
Map<String, IFunApp> ufs = new TreeMap<>();
Map<String, IExpression> usedAbbrevs = new TreeMap<>();
collectAllSymbolsAndAbbreviations(allVars, symbols, ufs, usedAbbrevs);
// declare normal symbols
for (Entry<String, IExpression> symbol : symbols.entrySet()) {
out.append(
String.format(
"(declare-fun %s () %s)%n",
SMTLineariser.quoteIdentifier(symbol.getKey()),
getFormulaType(symbol.getValue()).toSMTLIBString()));
}
// declare UFs
for (Entry<String, IFunApp> function : ufs.entrySet()) {
List<String> argSorts =
Lists.transform(
asJava(function.getValue().args()), a -> getFormulaType(a).toSMTLIBString());
out.append(
String.format(
"(declare-fun %s (%s) %s)%n",
SMTLineariser.quoteIdentifier(function.getKey()),
Joiner.on(" ").join(argSorts),
getFormulaType(function.getValue()).toSMTLIBString()));
}
// now every symbol from the formula or from abbreviations are declared,
// let's add the abbreviations, too.
for (String abbrev : getOrderedAbbreviations(usedAbbrevs)) {
IExpression abbrevFormula = usedAbbrevs.get(abbrev);
IExpression fullFormula = abbrevMap.get(abbrevFormula);
out.append(
String.format(
"(define-fun %s () %s %s)%n",
SMTLineariser.quoteIdentifier(abbrev),
getFormulaType(fullFormula).toSMTLIBString(),
SMTLineariser.asString(fullFormula)));
}
// now add the final assert
out.append("(assert ").append(SMTLineariser.asString(lettedFormula)).append(')');
}
/**
* determine all used symbols and all used abbreviations by traversing the abbreviations
* transitively.
*
* @param allVars will be updated with further symbols and UFs.
* @param symbols will be updated with all found symbols.
* @param ufs will be updated with all found UFs.
* @param abbrevs will be updated with all found abbreviations.
*/
private void collectAllSymbolsAndAbbreviations(
final Set<IExpression> allVars,
final Map<String, IExpression> symbols,
final Map<String, IFunApp> ufs,
final Map<String, IExpression> abbrevs) {
final Deque<IExpression> waitlistSymbols = new ArrayDeque<>(allVars);
final Set<String> seenSymbols = new HashSet<>();
while (!waitlistSymbols.isEmpty()) {
IExpression var = waitlistSymbols.poll();
String name = getName(var);
// we don't want to declare variables twice
if (!seenSymbols.add(name)) {
continue;
}
if (isAbbreviation(var)) {
Preconditions.checkState(!abbrevs.containsKey(name));
abbrevs.put(name, var);
// for abbreviations, we go deeper and analyse the abbreviated formula.
Set<IExpression> varsFromAbbrev = getVariablesFromAbbreviation(var);
Sets.difference(varsFromAbbrev, allVars).forEach(waitlistSymbols::push);
allVars.addAll(varsFromAbbrev);
} else if (var instanceof IFunApp) {
Preconditions.checkState(!ufs.containsKey(name));
ufs.put(name, (IFunApp) var);
} else {
Preconditions.checkState(!symbols.containsKey(name));
symbols.put(name, var);
}
}
}
/**
* Abbreviations can be nested, and thus we need to sort them. The returned list (or iterable)
* contains each used abbreviation exactly once. Abbreviations with no dependencies come
* first, more complex ones later.
*/
private Iterable<String> getOrderedAbbreviations(Map<String, IExpression> usedAbbrevs) {
ArrayDeque<String> waitlist = new ArrayDeque<>(usedAbbrevs.keySet());
Set<String> orderedAbbreviations = new LinkedHashSet<>();
while (!waitlist.isEmpty()) {
String abbrev = waitlist.removeFirst();
boolean allDependenciesFinished = true;
for (IExpression var : getVariablesFromAbbreviation(usedAbbrevs.get(abbrev))) {
String name = getName(var);
if (isAbbreviation(var)) {
if (!orderedAbbreviations.contains(name)) {
allDependenciesFinished = false;
waitlist.addLast(name); // part 1: add dependency for later
}
}
}
if (allDependenciesFinished) {
orderedAbbreviations.add(abbrev);
} else {
waitlist.addLast(abbrev); // part 2: add again for later
}
}
return orderedAbbreviations;
}
private boolean isAbbreviation(IExpression symbol) {
return abbrevMap.containsKey(symbol);
}
private Set<IExpression> getVariablesFromAbbreviation(IExpression var) {
return ImmutableSet.copyOf(
creator.extractVariablesAndUFs(abbrevMap.get(var), true).values());
}
};
}
private static String getName(IExpression var) {
if (var instanceof IAtom) {
return ((IAtom) var).pred().name();
} else if (var instanceof IConstant) {
return var.toString();
} else if (var instanceof IFunApp) {
String fullStr = ((IFunApp) var).fun().toString();
return fullStr.substring(0, fullStr.indexOf('/'));
} else if (var instanceof IIntFormula) {
return getName(((IIntFormula) var).t());
}
throw new IllegalArgumentException("The given parameter is no variable or function");
}
static FormulaType<?> getFormulaType(IExpression pFormula) {
if (pFormula instanceof IFormula) {
return FormulaType.BooleanType;
} else if (pFormula instanceof ITerm) {
final Sort sort = Sort$.MODULE$.sortOf((ITerm) pFormula);
try {
return getFormulaTypeFromSort(sort);
} catch (IllegalArgumentException e) {
// add more info about the formula, then rethrow
throw new IllegalArgumentException(
String.format(
"Unknown formula type '%s' for formula '%s'.", pFormula.getClass(), pFormula),
e);
}
}
throw new IllegalArgumentException(
String.format(
"Unknown formula type '%s' for formula '%s'.", pFormula.getClass(), pFormula));
}
private static FormulaType<?> getFormulaTypeFromSort(final Sort sort) {
if (sort == PrincessEnvironment.BOOL_SORT) {
return FormulaType.BooleanType;
} else if (sort == PrincessEnvironment.INTEGER_SORT) {
return FormulaType.IntegerType;
} else if (sort instanceof FractionSort$) {
return FormulaType.RationalType;
} else if (sort instanceof ExtArray.ArraySort) {
Seq<Sort> indexSorts = ((ExtArray.ArraySort) sort).theory().indexSorts();
Sort elementSort = ((ExtArray.ArraySort) sort).theory().objSort();
assert indexSorts.iterator().size() == 1 : "unexpected index type in Array type:" + sort;
// assert indexSorts.size() == 1; // TODO Eclipse does not like simpler code.
return FormulaType.getArrayType(
getFormulaTypeFromSort(indexSorts.iterator().next()), // get single index-sort
getFormulaTypeFromSort(elementSort));
} else if (sort instanceof MultipleValueBool$) {
return FormulaType.BooleanType;
} else {
scala.Option<Object> bitWidth = getBitWidth(sort);
if (bitWidth.isDefined()) {
return FormulaType.getBitvectorTypeWithSize((Integer) bitWidth.get());
}
}
throw new IllegalArgumentException(
String.format("Unknown formula type '%s' for sort '%s'.", sort.getClass(), sort));
}
static scala.Option<Object> getBitWidth(final Sort sort) {
scala.Option<Object> bitWidth = ModuloArithmetic.UnsignedBVSort$.MODULE$.unapply(sort);
if (!bitWidth.isDefined()) {
bitWidth = ModuloArithmetic.SignedBVSort$.MODULE$.unapply(sort);
}
return bitWidth;
}
public IExpression makeVariable(Sort type, String varname) {
if (type == BOOL_SORT) {
if (boolVariablesCache.containsKey(varname)) {
return boolVariablesCache.get(varname);
} else {
IFormula var = api.createBooleanVariable(varname);
addSymbol(var);
boolVariablesCache.put(varname, var);
return var;
}
} else {
if (sortedVariablesCache.containsKey(varname)) {
return sortedVariablesCache.get(varname);
} else {
ITerm var = api.createConstant(varname, type);
addSymbol(var);
sortedVariablesCache.put(varname, var);
return var;
}
}
}
/** This function declares a new functionSymbol with the given argument types and result. */
public IFunction declareFun(String name, Sort returnType, List<Sort> args) {
if (functionsCache.containsKey(name)) {
return functionsCache.get(name);
} else {
IFunction funcDecl =
api.createFunction(
name, toSeq(args), returnType, false, SimpleAPI.FunctionalityMode$.MODULE$.Full());
addFunction(funcDecl);
functionsCache.put(name, funcDecl);
return funcDecl;
}
}
public ITerm makeSelect(ITerm array, ITerm index) {
List<ITerm> args = ImmutableList.of(array, index);
ExtArray.ArraySort arraySort = (ExtArray.ArraySort) Sort$.MODULE$.sortOf(array);
return new IFunApp(arraySort.theory().select(), toSeq(args));
}
public ITerm makeStore(ITerm array, ITerm index, ITerm value) {
List<ITerm> args = ImmutableList.of(array, index, value);
ExtArray.ArraySort arraySort = (ExtArray.ArraySort) Sort$.MODULE$.sortOf(array);
return new IFunApp(arraySort.theory().store(), toSeq(args));
}
public boolean hasArrayType(IExpression exp) {
if (exp instanceof ITerm) {
final ITerm t = (ITerm) exp;
return Sort$.MODULE$.sortOf(t) instanceof ExtArray.ArraySort;
} else {
return false;
}
}
public IFormula elimQuantifiers(IFormula formula) {
return api.simplify(formula);
}
private void addSymbol(IFormula symbol) {
for (PrincessAbstractProver<?, ?> prover : registeredProvers) {
prover.addSymbol(symbol);
}
}
private void addSymbol(ITerm symbol) {
for (PrincessAbstractProver<?, ?> prover : registeredProvers) {
prover.addSymbol(symbol);
}
}
private void addFunction(IFunction funcDecl) {
for (PrincessAbstractProver<?, ?> prover : registeredProvers) {
prover.addSymbol(funcDecl);
}
}
static <T> Seq<T> toSeq(List<T> list) {
return collectionAsScalaIterableConverter(list).asScala().toSeq();
}
IExpression simplify(IExpression f) {
// TODO this method is not tested, check it!
if (f instanceof IFormula) {
f = BooleanCompactifier.apply((IFormula) f);
}
return PartialEvaluator.apply(f);
}
}
| 24,913 | 37.094801 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessFormulaCreator.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import static com.google.common.base.Preconditions.checkArgument;
import static org.sosy_lab.java_smt.api.QuantifiedFormulaManager.Quantifier.EXISTS;
import static org.sosy_lab.java_smt.api.QuantifiedFormulaManager.Quantifier.FORALL;
import static org.sosy_lab.java_smt.solvers.princess.PrincessEnvironment.toSeq;
import static scala.collection.JavaConverters.asJava;
import ap.basetypes.IdealInt;
import ap.parser.IAtom;
import ap.parser.IBinFormula;
import ap.parser.IBinJunctor;
import ap.parser.IBoolLit;
import ap.parser.IConstant;
import ap.parser.IEpsilon;
import ap.parser.IEquation;
import ap.parser.IExpression;
import ap.parser.IFormula;
import ap.parser.IFormulaITE;
import ap.parser.IFunApp;
import ap.parser.IFunction;
import ap.parser.IIntFormula;
import ap.parser.IIntLit;
import ap.parser.IIntRelation;
import ap.parser.INot;
import ap.parser.IPlus;
import ap.parser.IQuantified;
import ap.parser.ITerm;
import ap.parser.ITermITE;
import ap.parser.ITimes;
import ap.parser.IVariable;
import ap.terfor.conjunctions.Quantifier;
import ap.terfor.preds.Predicate;
import ap.theories.ExtArray;
import ap.theories.bitvectors.ModuloArithmetic;
import ap.theories.nia.GroebnerMultiplication$;
import ap.types.Sort;
import ap.types.Sort$;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Table;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
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.Formula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.FunctionDeclarationKind;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
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.princess.PrincessFunctionDeclaration.PrincessBitvectorToBitvectorDeclaration;
import org.sosy_lab.java_smt.solvers.princess.PrincessFunctionDeclaration.PrincessBitvectorToBooleanDeclaration;
import org.sosy_lab.java_smt.solvers.princess.PrincessFunctionDeclaration.PrincessByExampleDeclaration;
import org.sosy_lab.java_smt.solvers.princess.PrincessFunctionDeclaration.PrincessEquationDeclaration;
import org.sosy_lab.java_smt.solvers.princess.PrincessFunctionDeclaration.PrincessIFunctionDeclaration;
import org.sosy_lab.java_smt.solvers.princess.PrincessFunctionDeclaration.PrincessMultiplyDeclaration;
import scala.Enumeration;
class PrincessFormulaCreator
extends FormulaCreator<IExpression, Sort, PrincessEnvironment, PrincessFunctionDeclaration> {
// Hash-maps from interpreted functions and predicates to their corresponding
// Java-SMT kind
private static final Map<IFunction, FunctionDeclarationKind> theoryFunctionKind = new HashMap<>();
private static final Map<Predicate, FunctionDeclarationKind> theoryPredKind = new HashMap<>();
static {
theoryFunctionKind.put(ModuloArithmetic.bv_concat(), FunctionDeclarationKind.BV_CONCAT);
theoryFunctionKind.put(ModuloArithmetic.bv_extract(), FunctionDeclarationKind.BV_EXTRACT);
theoryFunctionKind.put(ModuloArithmetic.bv_not(), FunctionDeclarationKind.BV_NOT);
theoryFunctionKind.put(ModuloArithmetic.bv_neg(), FunctionDeclarationKind.BV_NEG);
theoryFunctionKind.put(ModuloArithmetic.bv_and(), FunctionDeclarationKind.BV_AND);
theoryFunctionKind.put(ModuloArithmetic.bv_or(), FunctionDeclarationKind.BV_OR);
theoryFunctionKind.put(ModuloArithmetic.bv_add(), FunctionDeclarationKind.BV_ADD);
theoryFunctionKind.put(ModuloArithmetic.bv_sub(), FunctionDeclarationKind.BV_SUB);
theoryFunctionKind.put(ModuloArithmetic.bv_mul(), FunctionDeclarationKind.BV_MUL);
theoryFunctionKind.put(ModuloArithmetic.bv_udiv(), FunctionDeclarationKind.BV_UDIV);
theoryFunctionKind.put(ModuloArithmetic.bv_sdiv(), FunctionDeclarationKind.BV_SDIV);
theoryFunctionKind.put(ModuloArithmetic.bv_urem(), FunctionDeclarationKind.BV_UREM);
theoryFunctionKind.put(ModuloArithmetic.bv_srem(), FunctionDeclarationKind.BV_SREM);
// modmod.bv_smod()?
theoryFunctionKind.put(ModuloArithmetic.bv_shl(), FunctionDeclarationKind.BV_SHL);
theoryFunctionKind.put(ModuloArithmetic.bv_lshr(), FunctionDeclarationKind.BV_LSHR);
theoryFunctionKind.put(ModuloArithmetic.bv_ashr(), FunctionDeclarationKind.BV_ASHR);
theoryFunctionKind.put(ModuloArithmetic.bv_xor(), FunctionDeclarationKind.BV_XOR);
// modmod.bv_xnor()?
// modmod.bv_comp()?
// casts to integer, sign/zero-extension?
theoryPredKind.put(ModuloArithmetic.bv_ult(), FunctionDeclarationKind.BV_ULT);
theoryPredKind.put(ModuloArithmetic.bv_ule(), FunctionDeclarationKind.BV_ULE);
theoryPredKind.put(ModuloArithmetic.bv_slt(), FunctionDeclarationKind.BV_SLT);
theoryPredKind.put(ModuloArithmetic.bv_sle(), FunctionDeclarationKind.BV_SLE);
theoryFunctionKind.put(GroebnerMultiplication$.MODULE$.mul(), FunctionDeclarationKind.MUL);
}
/**
* This mapping is a cache from index sort and element sort to the full array sort.
*
* <p>This mapping guarantees uniqueness of array types in JavaSMT, i.e. without this cache, we
* can not compare arrays, because all of them have distinct sorts, and SELECT/STORE operations
* are also incomparable and result in trivially satisfiable SMT queries (with no visible hint on
* the reason, except distinct sort objects).
*/
private final Table<Sort, Sort, Sort> arraySortCache = HashBasedTable.create();
PrincessFormulaCreator(PrincessEnvironment pEnv) {
super(pEnv, PrincessEnvironment.BOOL_SORT, PrincessEnvironment.INTEGER_SORT, null, null, null);
}
@Override
public Object convertValue(IExpression value) {
if (value instanceof IBoolLit) {
return ((IBoolLit) value).value();
} else if (value instanceof IIntLit) {
return ((IIntLit) value).value().bigIntValue();
}
if (value instanceof IFunApp) {
IFunApp fun = (IFunApp) value;
switch (fun.fun().name()) {
case "false":
assert fun.fun().arity() == 0;
return false;
case "mod_cast":
// we found a bitvector BV(lower, upper, ctxt), lets extract the last parameter
return ((IIntLit) fun.apply(2)).value().bigIntValue();
default:
}
}
throw new IllegalArgumentException(
"unhandled model value " + value + " of type " + value.getClass());
}
@Override
public FormulaType<?> getFormulaType(IExpression pFormula) {
return PrincessEnvironment.getFormulaType(pFormula);
}
@Override
public IExpression makeVariable(Sort type, String varName) {
return getEnv().makeVariable(type, varName);
}
@Override
public Sort getBitvectorType(int pBitwidth) {
return ModuloArithmetic.UnsignedBVSort$.MODULE$.apply(pBitwidth);
}
@Override
public Sort getFloatingPointType(FormulaType.FloatingPointType type) {
throw new UnsupportedOperationException("FloatingPoint theory is not supported by Princess");
}
@Override
public Sort getArrayType(Sort pIndexType, Sort pElementType) {
Sort result = arraySortCache.get(pIndexType, pElementType);
if (result == null) {
result = new ExtArray(toSeq(ImmutableList.of(pIndexType)), pElementType).sort();
arraySortCache.put(pIndexType, pElementType, result);
}
return result;
}
@SuppressWarnings("unchecked")
@Override
public <T extends Formula> FormulaType<T> getFormulaType(final T pFormula) {
if (pFormula instanceof BitvectorFormula) {
ITerm input = (ITerm) extractInfo(pFormula);
Sort sort = Sort$.MODULE$.sortOf(input);
scala.Option<Object> bitWidth = PrincessEnvironment.getBitWidth(sort);
checkArgument(
bitWidth.isDefined(), "BitvectorFormula with actual type %s: %s", sort, pFormula);
return (FormulaType<T>) FormulaType.getBitvectorTypeWithSize((Integer) bitWidth.get());
} else if (pFormula instanceof ArrayFormula<?, ?>) {
final FormulaType<?> arrayIndexType = getArrayFormulaIndexType((ArrayFormula<?, ?>) pFormula);
final FormulaType<?> arrayElementType =
getArrayFormulaElementType((ArrayFormula<?, ?>) pFormula);
return (FormulaType<T>) FormulaType.getArrayType(arrayIndexType, arrayElementType);
}
return super.getFormulaType(pFormula);
}
private String getName(IExpression input) {
if (input instanceof IAtom) {
return ((IAtom) input).pred().name();
} else if (input instanceof IConstant) {
return ((IConstant) input).c().name();
} else if (input instanceof IBinFormula) {
return ((IBinFormula) input).j().toString();
} else if (input instanceof IFormulaITE || input instanceof ITermITE) {
// in princess ite representation is the complete formula which we do not want here
return "ite";
} else if (input instanceof IIntFormula) {
return ((IIntFormula) input).rel().toString();
} else if (input instanceof INot) {
// in princess not representation is the complete formula which we do not want here
return "not";
} else if (input instanceof IFunApp) {
return ((IFunApp) input).fun().name();
} else if (input instanceof IPlus) {
// in princess plus representation is the complete formula which we do not want here
return "+";
} else if (input instanceof ITimes) {
// in princess times representation is the complete formula which we do not want here
return "*";
} else if (input instanceof IEpsilon) {
// in princess epsilon representation is the complete formula which we do not want here
return "eps";
} else if (input instanceof IEquation) {
return "=";
} else {
throw new AssertionError("Unhandled type " + input.getClass());
}
}
@Override
public <R> R visit(FormulaVisitor<R> visitor, final Formula f, final IExpression input) {
if (input instanceof IIntLit) {
IdealInt value = ((IIntLit) input).value();
return visitor.visitConstant(f, value.bigIntValue());
} else if (input instanceof IBoolLit) {
IBoolLit literal = (IBoolLit) input;
return visitor.visitConstant(f, literal.value());
// this is a quantifier
} else if (input instanceof IQuantified) {
BooleanFormula body = encapsulateBoolean(((IQuantified) input).subformula());
return visitor.visitQuantifier(
(BooleanFormula) f,
((IQuantified) input).quan().equals(Quantifier.apply(true)) ? FORALL : EXISTS,
// Princess does not hold any metadata about bound variables,
// so we can't get meaningful list here.
// HOWEVER, passing this list to QuantifiedFormulaManager#mkQuantifier
// works as expected.
new ArrayList<>(),
body);
// variable bound by a quantifier
} else if (input instanceof IVariable) {
return visitor.visitBoundVariable(f, ((IVariable) input).index());
// nullary atoms and constant are variables
} else if (((input instanceof IAtom) && asJava(((IAtom) input).args()).isEmpty())
|| input instanceof IConstant) {
return visitor.visitFreeVariable(f, input.toString());
// Princess encodes multiplication as "linear coefficient and factor" with arity 1.
} else if (input instanceof ITimes) {
assert input.length() == 1;
ITimes multiplication = (ITimes) input;
IIntLit coeff = new IIntLit(multiplication.coeff());
FormulaType<IntegerFormula> coeffType = FormulaType.IntegerType;
IExpression factor = multiplication.subterm();
FormulaType<?> factorType = getFormulaType(factor);
return visitor.visitFunction(
f,
ImmutableList.of(encapsulate(coeffType, coeff), encapsulate(factorType, factor)),
FunctionDeclarationImpl.of(
getName(input),
getDeclarationKind(input),
ImmutableList.of(coeffType, factorType),
getFormulaType(f),
PrincessMultiplyDeclaration.INSTANCE));
} else {
// then we have to check the declaration kind
final FunctionDeclarationKind kind = getDeclarationKind(input);
if (kind == FunctionDeclarationKind.EQ) {
scala.Option<scala.Tuple2<ITerm, ITerm>> maybeArgs =
IExpression.Eq$.MODULE$.unapply((IFormula) input);
assert maybeArgs.isDefined();
final ITerm left = maybeArgs.get()._1;
final ITerm right = maybeArgs.get()._2;
ImmutableList.Builder<Formula> args = ImmutableList.builder();
ImmutableList.Builder<FormulaType<?>> argTypes = ImmutableList.builder();
FormulaType<?> argumentTypeLeft = getFormulaType(left);
args.add(encapsulate(argumentTypeLeft, left));
argTypes.add(argumentTypeLeft);
FormulaType<?> argumentTypeRight = getFormulaType(right);
args.add(encapsulate(argumentTypeRight, right));
argTypes.add(argumentTypeRight);
return visitor.visitFunction(
f,
args.build(),
FunctionDeclarationImpl.of(
getName(input),
FunctionDeclarationKind.EQ,
argTypes.build(),
getFormulaType(f),
PrincessEquationDeclaration.INSTANCE));
} else if (kind == FunctionDeclarationKind.UF && input instanceof IIntFormula) {
assert ((IIntFormula) input).rel().equals(IIntRelation.EqZero());
// this is really a Boolean formula, visit the lhs of the equation
return visit(visitor, f, ((IIntFormula) input).t());
} else if (kind == FunctionDeclarationKind.OTHER
&& input instanceof IFunApp
&& ((IFunApp) input).fun() == ModuloArithmetic.mod_cast()
&& ((IFunApp) input).apply(2) instanceof IIntLit) {
return visitor.visitConstant(f, convertValue(input));
} else {
ImmutableList.Builder<Formula> args = ImmutableList.builder();
ImmutableList.Builder<FormulaType<?>> argTypes = ImmutableList.builder();
int arity = input.length();
int arityStart = 0;
PrincessFunctionDeclaration solverDeclaration;
if (isBitvectorOperationWithAdditionalArgument(kind)) {
// the first argument is the bitsize, and it is not relevant for the user.
// we do not want type/sort information as arguments.
arityStart = 1;
if (input instanceof IAtom) {
solverDeclaration = new PrincessBitvectorToBooleanDeclaration(((IAtom) input).pred());
} else if (input instanceof IFunApp) {
solverDeclaration =
new PrincessBitvectorToBitvectorDeclaration(((IFunApp) input).fun());
} else {
throw new AssertionError(
String.format("unexpected bitvector operation '%s' for formula '%s'", kind, input));
}
} else if (input instanceof IFunApp) {
if (kind == FunctionDeclarationKind.UF) {
solverDeclaration = new PrincessIFunctionDeclaration(((IFunApp) input).fun());
} else if (kind == FunctionDeclarationKind.MUL) {
solverDeclaration = PrincessMultiplyDeclaration.INSTANCE;
} else {
solverDeclaration = new PrincessByExampleDeclaration(input);
}
} else {
solverDeclaration = new PrincessByExampleDeclaration(input);
}
for (int i = arityStart; i < arity; i++) {
IExpression arg = input.apply(i);
FormulaType<?> argumentType = getFormulaType(arg);
args.add(encapsulate(argumentType, arg));
argTypes.add(argumentType);
}
return visitor.visitFunction(
f,
args.build(),
FunctionDeclarationImpl.of(
getName(input), kind, argTypes.build(), getFormulaType(f), solverDeclaration));
}
}
}
private boolean isBitvectorOperationWithAdditionalArgument(FunctionDeclarationKind kind) {
switch (kind) {
case BV_NOT:
case BV_NEG:
case BV_OR:
case BV_AND:
case BV_XOR:
case BV_SUB:
case BV_ADD:
case BV_SDIV:
case BV_UDIV:
case BV_SREM:
case BV_UREM:
case BV_MUL:
case BV_ULT:
case BV_SLT:
case BV_ULE:
case BV_SLE:
case BV_UGT:
case BV_SGT:
case BV_UGE:
case BV_SGE:
case BV_EQ:
return true;
default:
return false;
}
}
private FunctionDeclarationKind getDeclarationKind(IExpression input) {
assert !(((input instanceof IAtom) && asJava(((IAtom) input).args()).isEmpty())
|| input instanceof IConstant)
: "Variables should be handled somewhere else";
if (input instanceof IFormulaITE || input instanceof ITermITE) {
return FunctionDeclarationKind.ITE;
} else if (input instanceof IFunApp) {
final IFunction fun = ((IFunApp) input).fun();
final FunctionDeclarationKind theoryKind = theoryFunctionKind.get(fun);
if (theoryKind != null) {
return theoryKind;
} else if (ExtArray.Select$.MODULE$.unapply(fun).isDefined()) {
return FunctionDeclarationKind.SELECT;
} else if (ExtArray.Store$.MODULE$.unapply(fun).isDefined()) {
return FunctionDeclarationKind.STORE;
} else if (fun == ModuloArithmetic.mod_cast()) {
return FunctionDeclarationKind.OTHER;
} else if (fun == ModuloArithmetic.int_cast()) {
return FunctionDeclarationKind.OTHER;
} else {
return FunctionDeclarationKind.UF;
}
} else if (input instanceof IAtom) {
final Predicate pred = ((IAtom) input).pred();
final FunctionDeclarationKind theoryKind = theoryPredKind.get(pred);
if (theoryKind != null) {
return theoryKind;
} else {
return FunctionDeclarationKind.UF;
}
} else if (isBinaryFunction(input, IBinJunctor.And())) {
return FunctionDeclarationKind.AND;
} else if (isBinaryFunction(input, IBinJunctor.Or())) {
return FunctionDeclarationKind.OR;
} else if (input instanceof INot) {
return FunctionDeclarationKind.NOT;
} else if (isBinaryFunction(input, IBinJunctor.Eqv())) {
return FunctionDeclarationKind.IFF;
} else if (input instanceof ITimes) {
return FunctionDeclarationKind.MUL;
} else if (input instanceof IPlus) {
// SUB does not exist in princess a - b is a + (-b) there
return FunctionDeclarationKind.ADD;
} else if (input instanceof IEquation) {
return FunctionDeclarationKind.EQ;
} else if (input instanceof IIntFormula) {
IIntFormula f = (IIntFormula) input;
if (f.rel().equals(IIntRelation.EqZero())) {
final Sort sort = Sort$.MODULE$.sortOf(((IIntFormula) input).t());
if (sort == PrincessEnvironment.BOOL_SORT) {
// this is really a Boolean formula, it has to be UF
return FunctionDeclarationKind.UF;
} else if (sort == PrincessEnvironment.INTEGER_SORT) {
return FunctionDeclarationKind.EQ_ZERO;
} else {
return FunctionDeclarationKind.EQ;
}
} else if (f.rel().equals(IIntRelation.GeqZero())) {
return FunctionDeclarationKind.GTE_ZERO;
} else {
throw new AssertionError("Unhandled value for integer relation");
}
} else {
// we cannot handle XOR, IMPLIES, DISTINCT, DIV, MODULO, LT, LTE GT in princess
// they are either handled implicitly by the above-mentioned parts or not at all
return FunctionDeclarationKind.OTHER;
}
}
private static boolean isBinaryFunction(IExpression t, Enumeration.Value val) {
return (t instanceof IBinFormula) && val.equals(((IBinFormula) t).j()); // j is the operator
}
@Override
public PrincessFunctionDeclaration declareUFImpl(
String pName, Sort pReturnType, List<Sort> args) {
return new PrincessIFunctionDeclaration(environment.declareFun(pName, pReturnType, args));
}
@Override
public IExpression callFunctionImpl(
PrincessFunctionDeclaration declaration, List<IExpression> args) {
return declaration.makeApp(environment, args);
}
@Override
protected PrincessFunctionDeclaration getBooleanVarDeclarationImpl(IExpression pIExpression) {
return new PrincessByExampleDeclaration(pIExpression);
}
}
| 20,836 | 40.261386 | 114 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import ap.parser.IExpression;
import ap.parser.IFormula;
import ap.types.Sort;
import com.google.common.base.Preconditions;
import java.util.List;
import org.sosy_lab.common.Appender;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.basicimpl.AbstractFormulaManager;
final class PrincessFormulaManager
extends AbstractFormulaManager<
IExpression, Sort, PrincessEnvironment, PrincessFunctionDeclaration> {
private final PrincessFormulaCreator creator;
@SuppressWarnings("checkstyle:parameternumber")
PrincessFormulaManager(
PrincessFormulaCreator pCreator,
PrincessUFManager pFunctionManager,
PrincessBooleanFormulaManager pBooleanManager,
PrincessIntegerFormulaManager pIntegerManager,
PrincessBitvectorFormulaManager pBitpreciseManager,
PrincessArrayFormulaManager pArrayManager,
PrincessQuantifiedFormulaManager pQuantifierManager) {
super(
pCreator,
pFunctionManager,
pBooleanManager,
pIntegerManager,
null,
pBitpreciseManager,
null,
pQuantifierManager,
pArrayManager,
null,
null,
null);
creator = pCreator;
}
BooleanFormula encapsulateBooleanFormula(IExpression t) {
return getFormulaCreator().encapsulateBoolean(t);
}
@Override
public BooleanFormula parse(String pS) throws IllegalArgumentException {
List<? extends IExpression> formulas = getEnvironment().parseStringToTerms(pS, creator);
Preconditions.checkState(
formulas.size() == 1,
"parsing expects exactly one asserted term, but got %s terms",
formulas.size());
return encapsulateBooleanFormula(formulas.get(0));
}
@Override
public Appender dumpFormula(final IExpression formula) {
assert getFormulaCreator().getFormulaType(formula) == FormulaType.BooleanType
: "Only BooleanFormulas may be dumped";
return getEnvironment().dumpFormula((IFormula) formula, creator);
}
@Override
protected IExpression simplify(IExpression f) {
return getEnvironment().simplify(f);
}
}
| 2,448 | 30.397436 | 92 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessFunctionDeclaration.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import static com.google.common.base.Preconditions.checkArgument;
import static org.sosy_lab.java_smt.solvers.princess.PrincessEnvironment.toSeq;
import ap.basetypes.IdealInt;
import ap.parser.IAtom;
import ap.parser.IExpression;
import ap.parser.IExpression.BooleanFunApplier;
import ap.parser.IFormula;
import ap.parser.IFunApp;
import ap.parser.IFunction;
import ap.parser.IIntLit;
import ap.parser.ITerm;
import ap.parser.ITermITE;
import ap.terfor.preds.Predicate;
import ap.theories.nia.GroebnerMultiplication;
import ap.types.Sort;
import ap.types.Sort$;
import ap.types.SortedIFunction$;
import java.util.ArrayList;
import java.util.List;
import scala.collection.immutable.Seq;
/**
* Unlike other solvers, Princess does not have a class representing the built-in functions (OR,
* etc...). This interface wraps two cases: IFunction declaration (represented by IFunction), and
* declaration for a built-in function (represented by an example instantiation of the built-in
* function). The latter case does not have a valid {@code equals}, but it is not necessary, as it's
* not used in {@link org.sosy_lab.java_smt.basicimpl.FunctionDeclarationImpl}.
*/
abstract class PrincessFunctionDeclaration {
private PrincessFunctionDeclaration() {}
abstract IExpression makeApp(PrincessEnvironment environment, List<IExpression> args);
private abstract static class AbstractDeclaration<T> extends PrincessFunctionDeclaration {
/** some object representing the functon declaration. */
protected final T declarationItem;
AbstractDeclaration(T pDeclaration) {
declarationItem = pDeclaration;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof AbstractDeclaration<?>)) {
return false;
}
AbstractDeclaration<?> other = (AbstractDeclaration<?>) o;
return declarationItem.equals(other.declarationItem);
}
@Override
abstract IExpression makeApp(PrincessEnvironment env, List<IExpression> args);
@Override
public int hashCode() {
return declarationItem.hashCode();
}
@Override
public String toString() {
return declarationItem.toString();
}
}
static class PrincessIFunctionDeclaration extends AbstractDeclaration<IFunction> {
PrincessIFunctionDeclaration(IFunction pApp) {
super(pApp);
}
@Override
public IExpression makeApp(PrincessEnvironment env, List<IExpression> args) {
// TODO: check argument types
checkArgument(
args.size() == declarationItem.arity(), "functiontype has different number of args.");
final List<ITerm> argsList = new ArrayList<>();
for (IExpression arg : args) {
ITerm termArg;
if (arg instanceof IFormula) { // boolean term -> build ITE(t,0,1)
termArg =
new ITermITE(
(IFormula) arg, new IIntLit(IdealInt.ZERO()), new IIntLit(IdealInt.ONE()));
} else {
termArg = (ITerm) arg;
}
argsList.add(termArg);
}
final Seq<ITerm> argsBuf = toSeq(argsList);
IFunApp returnFormula = new IFunApp(declarationItem, argsBuf);
Sort returnType = SortedIFunction$.MODULE$.iResultSort(declarationItem, returnFormula.args());
// boolean term, so we have to use the fun-applier instead of the function itself
if (returnType == PrincessEnvironment.BOOL_SORT) {
BooleanFunApplier ap = new BooleanFunApplier(declarationItem);
return ap.apply(argsBuf);
} else {
return returnFormula;
}
}
}
static class PrincessByExampleDeclaration extends AbstractDeclaration<IExpression> {
PrincessByExampleDeclaration(IExpression pExample) {
super(pExample);
}
@Override
public IExpression makeApp(PrincessEnvironment env, List<IExpression> args) {
return declarationItem.update(toSeq(args));
}
}
static class PrincessBitvectorToBooleanDeclaration extends AbstractDeclaration<Predicate> {
PrincessBitvectorToBooleanDeclaration(Predicate pPredicate) {
super(pPredicate);
}
@Override
public IExpression makeApp(PrincessEnvironment env, List<IExpression> args) {
ITerm arg0 = (ITerm) args.get(0);
Sort sort = Sort$.MODULE$.sortOf(arg0);
scala.Option<Object> bitWidth = PrincessEnvironment.getBitWidth(sort);
checkArgument(bitWidth.isDefined(), "BitvectorFormula with actual type %s: %s", sort, arg0);
int bitsize = (Integer) bitWidth.get();
List<ITerm> newArgs = new ArrayList<>();
newArgs.add(new IIntLit(IdealInt.apply(bitsize)));
for (IExpression arg : args) {
newArgs.add((ITerm) arg);
}
return new IAtom(declarationItem, toSeq(newArgs));
}
}
static class PrincessBitvectorToBitvectorDeclaration extends AbstractDeclaration<IFunction> {
PrincessBitvectorToBitvectorDeclaration(IFunction pFunction) {
super(pFunction);
}
@Override
public IExpression makeApp(PrincessEnvironment env, List<IExpression> args) {
ITerm arg0 = (ITerm) args.get(0);
Sort sort = Sort$.MODULE$.sortOf(arg0);
scala.Option<Object> bitWidth = PrincessEnvironment.getBitWidth(sort);
checkArgument(bitWidth.isDefined(), "BitvectorFormula with actual type %s: %s", sort, arg0);
int bitsize = (Integer) bitWidth.get();
List<ITerm> newArgs = new ArrayList<>();
newArgs.add(new IIntLit(IdealInt.apply(bitsize)));
for (IExpression arg : args) {
newArgs.add((ITerm) arg);
}
return new IFunApp(declarationItem, toSeq(newArgs));
}
}
static class PrincessEquationDeclaration extends PrincessFunctionDeclaration {
static final PrincessEquationDeclaration INSTANCE = new PrincessEquationDeclaration() {};
private PrincessEquationDeclaration() {}
@Override
public IExpression makeApp(PrincessEnvironment env, List<IExpression> args) {
checkArgument(args.size() == 2);
return ((ITerm) args.get(0)).$eq$eq$eq((ITerm) args.get(1));
}
}
static class PrincessMultiplyDeclaration extends PrincessFunctionDeclaration {
static final PrincessMultiplyDeclaration INSTANCE = new PrincessMultiplyDeclaration() {};
private PrincessMultiplyDeclaration() {}
@Override
public IExpression makeApp(PrincessEnvironment env, List<IExpression> args) {
checkArgument(args.size() == 2);
return GroebnerMultiplication.mult((ITerm) args.get(0), (ITerm) args.get(1));
}
}
}
| 6,775 | 32.544554 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessIntegerFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import ap.basetypes.IdealInt;
import ap.parser.IExpression;
import ap.parser.IIntLit;
import ap.parser.ITerm;
import ap.theories.nia.GroebnerMultiplication;
import ap.types.Sort;
import java.math.BigDecimal;
import java.math.BigInteger;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
class PrincessIntegerFormulaManager
extends PrincessNumeralFormulaManager<IntegerFormula, IntegerFormula>
implements IntegerFormulaManager {
PrincessIntegerFormulaManager(
PrincessFormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
}
@Override
protected ITerm makeNumberImpl(long i) {
return new IIntLit(IdealInt.apply(i));
}
@Override
protected ITerm makeNumberImpl(BigInteger pI) {
return new IIntLit(IdealInt.apply(pI.toString()));
}
@Override
protected ITerm makeNumberImpl(String pI) {
return new IIntLit(IdealInt.apply(pI));
}
@Override
protected ITerm makeNumberImpl(double pNumber) {
return makeNumberImpl((long) pNumber);
}
@Override
protected IExpression makeNumberImpl(BigDecimal pNumber) {
return decimalAsInteger(pNumber);
}
@Override
protected IExpression makeVariableImpl(String varName) {
Sort t = getFormulaCreator().getIntegerType();
return getFormulaCreator().makeVariable(t, varName);
}
@Override
protected IExpression modularCongruence(
IExpression pNumber1, IExpression pNumber2, long pModulo) {
return modularCongruence0(pNumber1, pNumber2, makeNumberImpl(pModulo));
}
@Override
protected IExpression modularCongruence(
IExpression pNumber1, IExpression pNumber2, BigInteger pModulo) {
return modularCongruence0(pNumber1, pNumber2, makeNumberImpl(pModulo));
}
private IExpression modularCongruence0(IExpression pNumber1, IExpression pNumber2, ITerm n) {
// ((_ divisible n) x) <==> (= x (* n (div x n)))
// ITerm x = subtract(pNumber1, pNumber2);
// return x.$eq$eq$eq(n.$times(BitShiftMultiplication.eDiv(x, n)));
// exists v0. pNumber1 - pNumber2 + v0*n == 0
ITerm diff = subtract(pNumber1, pNumber2);
ITerm sum = add(diff, multiply(IExpression.v(0), n));
return IExpression.ex(IExpression.eqZero(sum));
}
@Override
public IExpression divide(IExpression pNumber1, IExpression pNumber2) {
return GroebnerMultiplication.eDivWithSpecialZero((ITerm) pNumber1, (ITerm) pNumber2);
}
@Override
public IExpression modulo(IExpression pNumber1, IExpression pNumber2) {
return GroebnerMultiplication.eModWithSpecialZero((ITerm) pNumber1, (ITerm) pNumber2);
}
@Override
public IExpression multiply(IExpression pNumber1, IExpression pNumber2) {
return GroebnerMultiplication.mult((ITerm) pNumber1, (ITerm) pNumber2);
}
@Override
protected boolean isNumeral(IExpression val) {
return val instanceof IIntLit;
}
}
| 3,241 | 30.173077 | 95 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessInterpolatingProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import static scala.collection.JavaConverters.asJava;
import static scala.collection.JavaConverters.asScala;
import ap.api.SimpleAPI;
import ap.basetypes.Tree;
import ap.parser.IBoolLit;
import ap.parser.IExpression;
import ap.parser.IFormula;
import com.google.common.base.Preconditions;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.graph.Traverser;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Deque;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.common.UniqueIdGenerator;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
import scala.collection.Seq;
import scala.collection.mutable.ArrayBuffer;
class PrincessInterpolatingProver extends PrincessAbstractProver<Integer, Integer>
implements InterpolatingProverEnvironment<Integer> {
private final Map<Integer, IFormula> annotatedTerms = new HashMap<>(); // Collection of termNames
private static final UniqueIdGenerator counter = new UniqueIdGenerator(); // for different indices
PrincessInterpolatingProver(
PrincessFormulaManager pMgr,
PrincessFormulaCreator creator,
SimpleAPI pApi,
ShutdownNotifier pShutdownNotifier,
Set<ProverOptions> pOptions) {
super(pMgr, creator, pApi, pShutdownNotifier, pOptions);
}
@Override
public void pop() {
Preconditions.checkState(!closed);
assertedFormulas.peek().forEach(annotatedTerms::remove);
super.pop();
}
@Override
public Integer addConstraint(BooleanFormula f) {
Preconditions.checkState(!closed);
int termIndex = counter.getFreshId();
IFormula t = (IFormula) mgr.extractInfo(f);
// set partition number and add formula
api.setPartitionNumber(termIndex);
addConstraint0(t);
// reset partition number to magic number -1,
// which represents formulae belonging to all partitions.
api.setPartitionNumber(-1);
assertedFormulas.peek().add(termIndex);
annotatedTerms.put(termIndex, t);
return termIndex;
}
@Override
protected Iterable<IExpression> getAssertedFormulas() {
return FluentIterable.concat(assertedFormulas).transform(annotatedTerms::get);
}
@Override
public BooleanFormula getInterpolant(Collection<Integer> pTermNamesOfA) throws SolverException {
Preconditions.checkState(!closed);
Set<Integer> indexesOfA = ImmutableSet.copyOf(pTermNamesOfA);
// calc difference: termNamesOfB := assertedFormulas - termNamesOfA
Set<Integer> indexesOfB =
annotatedTerms.keySet().stream()
.filter(f -> !indexesOfA.contains(f))
.collect(ImmutableSet.toImmutableSet());
// get interpolant of groups
List<BooleanFormula> itp = getSeqInterpolants(ImmutableList.of(indexesOfA, indexesOfB));
assert itp.size() == 1; // 2 groups -> 1 interpolant
return itp.get(0);
}
@Override
public List<BooleanFormula> getSeqInterpolants(
final List<? extends Collection<Integer>> partitions) throws SolverException {
Preconditions.checkState(!closed);
Preconditions.checkArgument(
!partitions.isEmpty(), "at least one partition should be available.");
// convert to needed data-structure
final ArrayBuffer<scala.collection.immutable.Set<Object>> args = new ArrayBuffer<>();
for (Collection<Integer> partition : partitions) {
args.$plus$eq(asScala(partition).toSet());
}
// do the hard work
final Seq<IFormula> itps;
try {
itps = api.getInterpolants(args.toSeq(), api.getInterpolants$default$2());
} catch (StackOverflowError e) {
// Princess is recursive and thus produces stack overflows on large formulas.
// Princess itself also catches StackOverflowError and returns "OutOfMemory" in checkSat(),
// so we can do the same for getInterpolants().
throw new SolverException(
"Princess ran out of stack memory, try increasing the stack size.", e);
}
assert itps.length() == partitions.size() - 1
: "There should be (n-1) interpolants for n partitions";
// convert data-structure back
// TODO check that interpolants do not contain abbreviations we did not introduce ourselves
final List<BooleanFormula> result = new ArrayList<>();
for (final IFormula itp : asJava(itps)) {
result.add(mgr.encapsulateBooleanFormula(itp));
}
return result;
}
@Override
public List<BooleanFormula> getTreeInterpolants(
List<? extends Collection<Integer>> partitionedFormulas, int[] startOfSubTree)
throws SolverException {
Preconditions.checkState(!closed);
assert InterpolatingProverEnvironment.checkTreeStructure(
partitionedFormulas.size(), startOfSubTree);
// reconstruct the trees from the labels in post-order
final Deque<Tree<scala.collection.immutable.Set<Object>>> stack = new ArrayDeque<>();
final Deque<Integer> subtreeStarts = new ArrayDeque<>();
for (int i = 0; i < partitionedFormulas.size(); ++i) {
Preconditions.checkState(stack.size() == subtreeStarts.size());
int start = startOfSubTree[i];
ArrayBuffer<Tree<scala.collection.immutable.Set<Object>>> children = new ArrayBuffer<>();
// while-loop: inner node -> merge children
// otherwise: leaf-node -> start new subtree, no children
while (!subtreeStarts.isEmpty() && start <= subtreeStarts.peek()) {
subtreeStarts.pop();
children.$plus$eq$colon(stack.pop()); // prepend
}
subtreeStarts.push(start);
stack.push(new Tree<>(asScala(partitionedFormulas.get(i)).toSet(), children.toList()));
}
Preconditions.checkState(subtreeStarts.peek() == 0, "subtree of root should start at 0.");
Tree<scala.collection.immutable.Set<Object>> root = stack.pop();
Preconditions.checkState(stack.isEmpty(), "root should be last element in stack.");
final Tree<IFormula> itps;
try {
itps = api.getTreeInterpolant(root, api.getTreeInterpolant$default$2());
} catch (StackOverflowError e) {
// Princess is recursive and thus produces stack overflows on large formulas.
// Princess itself also catches StackOverflowError and returns "OutOfMemory" in checkSat(),
// so we can do the same for getInterpolants().
throw new SolverException(
"Princess ran out of stack memory, try increasing the stack size.", e);
}
List<BooleanFormula> result = tree2List(itps);
assert result.size() == startOfSubTree.length - 1;
return result;
}
/** returns a post-order iteration of the tree. */
private List<BooleanFormula> tree2List(Tree<IFormula> tree) {
List<BooleanFormula> lst =
FluentIterable.from(
Traverser.<Tree<IFormula>>forTree(node -> asJava(node.children()))
.depthFirstPostOrder(tree))
.transform(node -> mgr.encapsulateBooleanFormula(node.d()))
.toList();
// root of interpolation tree is false, and we have to remove it.
assert Iterables.getLast(lst).equals(mgr.encapsulateBooleanFormula(new IBoolLit(false)));
return lst.subList(0, lst.size() - 1);
}
}
| 7,817 | 37.70297 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessModel.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import static scala.collection.JavaConverters.asJava;
import ap.api.PartialModel;
import ap.api.SimpleAPI;
import ap.parser.IAtom;
import ap.parser.IBinFormula;
import ap.parser.IBinJunctor;
import ap.parser.IConstant;
import ap.parser.IExpression;
import ap.parser.IFormula;
import ap.parser.IFunApp;
import ap.parser.ITerm;
import ap.terfor.preds.Predicate;
import ap.theories.ExtArray;
import ap.theories.ExtArray.ArraySort;
import ap.types.Sort;
import ap.types.Sort$;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Multimap;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.sosy_lab.java_smt.basicimpl.AbstractModel;
import org.sosy_lab.java_smt.basicimpl.AbstractProver;
import org.sosy_lab.java_smt.basicimpl.FormulaCreator;
import scala.Option;
class PrincessModel extends AbstractModel<IExpression, Sort, PrincessEnvironment> {
private final PartialModel model;
private final SimpleAPI api;
PrincessModel(
AbstractProver<?> pProver,
PartialModel partialModel,
FormulaCreator<IExpression, Sort, PrincessEnvironment, ?> creator,
SimpleAPI pApi) {
super(pProver, creator);
this.model = partialModel;
this.api = pApi;
}
@Override
public ImmutableList<ValueAssignment> asList() {
scala.collection.Map<IExpression, IExpression> interpretation = model.interpretation();
// get abbreviations, we do not want to export them.
Set<Predicate> abbrevs = new LinkedHashSet<>();
for (var entry : asJava(api.ap$api$SimpleAPI$$apiStack().abbrevPredicates()).entrySet()) {
abbrevs.add(entry.getKey()); // collect the abbreviation.
abbrevs.add(entry.getValue()._2()); // the definition is also handled as abbreviation here.
}
// first get the addresses of arrays
Multimap<IFunApp, ITerm> arrays = getArrays(interpretation);
// then iterate over the model and generate the assignments
ImmutableSet.Builder<ValueAssignment> assignments = ImmutableSet.builder();
for (Map.Entry<IExpression, IExpression> entry : asJava(interpretation).entrySet()) {
if (!isAbbrev(abbrevs, entry.getKey())) {
assignments.addAll(getAssignments(entry.getKey(), entry.getValue(), arrays));
}
}
return assignments.build().asList();
}
private boolean isAbbrev(Set<Predicate> abbrevs, IExpression var) {
return var instanceof IAtom && abbrevs.contains(((IAtom) var).pred());
}
/**
* Collect array-models, we need them to replace identifiers later.
*
* <p>Princess models arrays as filled, based on a zero-filled array. The model for an
* array-access (via 'select') uses the filled array instead of the name and is handled later (see
* #getAssignment). The model gives more information, like the (partially) filled array and all
* array accesses based on (here comes the weird part:) some intermediate array evaluation.
*
* <p>Example: "arr[5]=123" with a following "result_arr[6]=123" (writing into an array in SMT
* returns a new copy of it!) is modeled as
*
* <pre>
* {
* x -> 123,
* arr -> store(const(0), 5, 123),
* store(store(const(0), 5, 123), 6, 123) -> store(store(const(0), 5, 123), 6, 123),
* select(store(const(0), 5, 123), 5) -> 123
* }
* </pre>
*
* <p>The returned mapping contains the mapping of the complete array value ("store(const(0), 5,
* 123)") to the identifier ("arr").
*/
private Multimap<IFunApp, ITerm> getArrays(
scala.collection.Map<IExpression, IExpression> interpretation) {
Multimap<IFunApp, ITerm> arrays = ArrayListMultimap.create();
for (Map.Entry<IExpression, IExpression> entry : asJava(interpretation).entrySet()) {
if (entry.getKey() instanceof IConstant) {
ITerm maybeArray = (IConstant) entry.getKey();
IExpression value = entry.getValue();
if (creator.getEnv().hasArrayType(maybeArray)
&& value instanceof IFunApp
&& ExtArray.Store$.MODULE$.unapply(((IFunApp) value).fun()).isDefined()) {
// It is value -> variables, hence if 2+ vars have the same value we need a list
arrays.put((IFunApp) value, maybeArray);
}
}
}
return arrays;
}
private ImmutableList<ValueAssignment> getAssignments(
IExpression key, IExpression value, Multimap<IFunApp, ITerm> pArrays) {
// first check array-access, for explanation see #getArrays.
// those cases can return multiple assignments per model entry.
if (key instanceof IConstant) {
if (creator.getEnv().hasArrayType(key)) {
return ImmutableList.of();
}
} else if (key instanceof IFunApp) {
IFunApp cKey = (IFunApp) key;
if ("valueAlmostEverywhere".equals(cKey.fun().name())
&& creator.getEnv().hasArrayType(Iterables.getOnlyElement(asJava(cKey.args())))) {
return ImmutableList.of();
}
Sort sort = Sort$.MODULE$.sortOf(cKey);
if (ExtArray.Select$.MODULE$.unapply(cKey.fun()).isDefined()) {
return getAssignmentsFromArraySelect(value, cKey, pArrays);
} else if (sort instanceof ArraySort) {
ExtArray arrayTheory = ((ArraySort) sort).theory();
if (arrayTheory.store() == cKey.fun()) {
return getAssignmentsFromArrayStore((IFunApp) value, cKey, pArrays);
} else if (arrayTheory.store2() == cKey.fun()) {
return getAssignmentsFromArrayStore((IFunApp) value, cKey, pArrays);
}
}
}
// then handle assignments for non-array cases.
// we expect exactly one assignment per model entry.
String name;
IFormula fAssignment;
List<Object> argumentInterpretations = ImmutableList.of();
if (key instanceof IAtom) {
name = key.toString();
fAssignment = new IBinFormula(IBinJunctor.Eqv(), (IAtom) key, (IFormula) value);
} else if (key instanceof IConstant) {
name = key.toString();
fAssignment = ((IConstant) key).$eq$eq$eq((ITerm) value);
} else if (key instanceof IFunApp) {
// normal variable or UF
IFunApp cKey = (IFunApp) key;
argumentInterpretations = new ArrayList<>();
for (ITerm arg : asJava(cKey.args())) {
argumentInterpretations.add(creator.convertValue(arg));
}
name = cKey.fun().name();
fAssignment = ((ITerm) key).$eq$eq$eq((ITerm) value);
} else {
throw new AssertionError(
String.format("unknown type of key: %s -> %s (%s)", key, value, key.getClass()));
}
return ImmutableList.of(
new ValueAssignment(
creator.encapsulateWithTypeOf(key),
creator.encapsulateWithTypeOf(value),
creator.encapsulateBoolean(fAssignment),
name,
creator.convertValue(value),
argumentInterpretations));
}
/** array-access, for explanation see #getArrayAddresses. */
private ImmutableList<ValueAssignment> getAssignmentsFromArraySelect(
IExpression fValue, IFunApp cKey, Multimap<IFunApp, ITerm> pArrays) {
IFunApp arrayId = (IFunApp) cKey.args().apply(Integer.valueOf(0));
ITerm arrayIndex = cKey.args().apply(Integer.valueOf(1));
ImmutableList.Builder<ValueAssignment> arrayAssignments = ImmutableList.builder();
for (ITerm arrayF : pArrays.get(arrayId)) {
ITerm select = creator.getEnv().makeSelect(arrayF, arrayIndex);
arrayAssignments.add(
new ValueAssignment(
creator.encapsulateWithTypeOf(select),
creator.encapsulateWithTypeOf(fValue),
creator.encapsulateBoolean(select.$eq$eq$eq((ITerm) fValue)),
arrayF.toString(),
creator.convertValue(fValue),
ImmutableList.of(creator.convertValue(arrayIndex))));
}
return arrayAssignments.build();
}
/** array-access, for explanation see #getArrayAddresses. */
private ImmutableList<ValueAssignment> getAssignmentsFromArrayStore(
IFunApp value, IFunApp cKey, Multimap<IFunApp, ITerm> pArrays) {
ITerm arrayIndex = cKey.args().apply(Integer.valueOf(1));
ITerm arrayContent = cKey.args().apply(Integer.valueOf(2));
ImmutableList.Builder<ValueAssignment> arrayAssignments = ImmutableList.builder();
for (ITerm arrayF : pArrays.get(value)) {
ITerm select = creator.getEnv().makeSelect(arrayF, arrayIndex);
arrayAssignments.add(
new ValueAssignment(
creator.encapsulateWithTypeOf(select),
creator.encapsulateWithTypeOf(arrayContent),
creator.encapsulateBoolean(select.$eq$eq$eq(arrayContent)),
arrayF.toString(),
creator.convertValue(arrayContent),
ImmutableList.of(creator.convertValue(arrayIndex))));
}
return arrayAssignments.build();
}
@Override
public String toString() {
return model.toString();
}
@Override
public void close() {}
@Override
protected IExpression evalImpl(IExpression formula) {
IExpression evaluation = evaluate(formula);
if (evaluation == null) {
// fallback: try to simplify the query and evaluate again.
evaluation = evaluate(creator.getEnv().simplify(formula));
}
return evaluation;
}
@Nullable
private IExpression evaluate(IExpression formula) {
if (formula instanceof ITerm) {
Option<ITerm> out = model.evalToTerm((ITerm) formula);
return out.isEmpty() ? null : out.get();
} else if (formula instanceof IFormula) {
Option<IExpression> out = model.evalExpression(formula);
return out.isEmpty() ? null : out.get();
} else {
throw new AssertionError("unexpected formula: " + formula);
}
}
}
| 10,218 | 37.417293 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessNumeralFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import static scala.collection.JavaConverters.asScala;
import ap.parser.IExpression;
import ap.parser.IFormula;
import ap.parser.ITerm;
import ap.types.Sort;
import com.google.common.collect.Iterables;
import java.util.List;
import org.sosy_lab.java_smt.api.NumeralFormula;
import org.sosy_lab.java_smt.basicimpl.AbstractNumeralFormulaManager;
@SuppressWarnings("ClassTypeParameterName")
abstract class PrincessNumeralFormulaManager<
ParamFormulaType extends NumeralFormula, ResultFormulaType extends NumeralFormula>
extends AbstractNumeralFormulaManager<
IExpression,
Sort,
PrincessEnvironment,
ParamFormulaType,
ResultFormulaType,
PrincessFunctionDeclaration> {
PrincessNumeralFormulaManager(
PrincessFormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
}
@Override
protected ITerm negate(IExpression pNumber) {
return ((ITerm) pNumber).unary_$minus();
}
@Override
protected ITerm add(IExpression pNumber1, IExpression pNumber2) {
return ((ITerm) pNumber1).$plus((ITerm) pNumber2);
}
@Override
protected ITerm subtract(IExpression pNumber1, IExpression pNumber2) {
return ((ITerm) pNumber1).$minus((ITerm) pNumber2);
}
@Override
protected IFormula equal(IExpression pNumber1, IExpression pNumber2) {
return ((ITerm) pNumber1).$eq$eq$eq((ITerm) pNumber2);
}
@Override
protected IExpression distinctImpl(List<IExpression> pNumbers) {
return IExpression.distinct(asScala(Iterables.filter(pNumbers, ITerm.class)));
}
@Override
protected IFormula greaterThan(IExpression pNumber1, IExpression pNumber2) {
return ((ITerm) pNumber1).$greater((ITerm) pNumber2);
}
@Override
protected IFormula greaterOrEquals(IExpression pNumber1, IExpression pNumber2) {
return ((ITerm) pNumber1).$greater$eq((ITerm) pNumber2);
}
@Override
protected IFormula lessThan(IExpression pNumber1, IExpression pNumber2) {
return ((ITerm) pNumber1).$less((ITerm) pNumber2);
}
@Override
protected IFormula lessOrEquals(IExpression pNumber1, IExpression pNumber2) {
return ((ITerm) pNumber1).$less$eq((ITerm) pNumber2);
}
}
| 2,511 | 29.26506 | 90 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessQuantifiedFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import static com.google.common.base.Preconditions.checkArgument;
import static scala.collection.JavaConverters.asScala;
import ap.parser.IConstant;
import ap.parser.IExpression;
import ap.parser.IFormula;
import ap.parser.ISortedQuantified;
import ap.terfor.ConstantTerm;
import ap.terfor.conjunctions.Quantifier.ALL$;
import ap.terfor.conjunctions.Quantifier.EX$;
import ap.types.Sort;
import java.util.ArrayList;
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;
class PrincessQuantifiedFormulaManager
extends AbstractQuantifiedFormulaManager<
IExpression, Sort, PrincessEnvironment, PrincessFunctionDeclaration> {
private final PrincessEnvironment env;
PrincessQuantifiedFormulaManager(
FormulaCreator<IExpression, Sort, PrincessEnvironment, PrincessFunctionDeclaration>
pCreator) {
super(pCreator);
env = getFormulaCreator().getEnv();
}
@Override
public IExpression mkQuantifier(Quantifier q, List<IExpression> vars, IExpression body) {
checkArgument(body instanceof IFormula);
ap.terfor.conjunctions.Quantifier pq = (q == Quantifier.FORALL) ? ALL$.MODULE$ : EX$.MODULE$;
if (vars.isEmpty()) {
// Body already contains bound variables.
return new ISortedQuantified(pq, PrincessEnvironment.INTEGER_SORT, (IFormula) body);
} else {
// TODO: add support for boolean quantification!
return IExpression.quanConsts(pq, asScala(toConstantTerm(vars)), (IFormula) body);
}
}
private List<ConstantTerm> toConstantTerm(List<IExpression> lst) {
List<ConstantTerm> retVal = new ArrayList<>(lst.size());
for (IExpression f : lst) {
retVal.add(((IConstant) f).c());
}
return retVal;
}
@Override
protected IExpression eliminateQuantifiers(IExpression formula)
throws SolverException, InterruptedException {
checkArgument(formula instanceof IFormula);
return env.elimQuantifiers((IFormula) formula);
}
}
| 2,378 | 32.985714 | 97 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessSolverContext.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import ap.api.SimpleAPI;
import java.util.Set;
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.io.PathCounterTemplate;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
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.api.SolverContext;
import org.sosy_lab.java_smt.basicimpl.AbstractNumeralFormulaManager.NonLinearArithmetic;
import org.sosy_lab.java_smt.basicimpl.AbstractSolverContext;
public final class PrincessSolverContext extends AbstractSolverContext {
private final PrincessFormulaManager manager;
private final PrincessFormulaCreator creator;
private PrincessSolverContext(PrincessFormulaManager manager, PrincessFormulaCreator creator) {
super(manager);
this.manager = manager;
this.creator = creator;
}
public static SolverContext create(
Configuration config,
ShutdownNotifier pShutdownNotifier,
@Nullable PathCounterTemplate pLogfileTemplate,
int pRandomSeed,
NonLinearArithmetic pNonLinearArithmetic)
throws InvalidConfigurationException {
PrincessEnvironment env =
new PrincessEnvironment(config, pLogfileTemplate, pShutdownNotifier, pRandomSeed);
PrincessFormulaCreator creator = new PrincessFormulaCreator(env);
// Create managers
PrincessUFManager functionTheory = new PrincessUFManager(creator);
PrincessBooleanFormulaManager booleanTheory = new PrincessBooleanFormulaManager(creator);
PrincessIntegerFormulaManager integerTheory =
new PrincessIntegerFormulaManager(creator, pNonLinearArithmetic);
PrincessBitvectorFormulaManager bitvectorTheory =
new PrincessBitvectorFormulaManager(creator, booleanTheory);
PrincessArrayFormulaManager arrayTheory = new PrincessArrayFormulaManager(creator);
PrincessQuantifiedFormulaManager quantifierTheory =
new PrincessQuantifiedFormulaManager(creator);
PrincessFormulaManager manager =
new PrincessFormulaManager(
creator,
functionTheory,
booleanTheory,
integerTheory,
bitvectorTheory,
arrayTheory,
quantifierTheory);
return new PrincessSolverContext(manager, creator);
}
@SuppressWarnings("resource")
@Override
protected ProverEnvironment newProverEnvironment0(Set<ProverOptions> options) {
if (options.contains(ProverOptions.GENERATE_UNSAT_CORE_OVER_ASSUMPTIONS)) {
throw new UnsupportedOperationException(
"Princess does not support unsat core generation with assumptions yet");
}
return (PrincessTheoremProver) creator.getEnv().getNewProver(false, manager, creator, options);
}
@SuppressWarnings("resource")
@Override
protected InterpolatingProverEnvironment<?> newProverEnvironmentWithInterpolation0(
Set<ProverOptions> options) {
return (PrincessInterpolatingProver)
creator.getEnv().getNewProver(true, manager, creator, options);
}
@Override
public OptimizationProverEnvironment newOptimizationProverEnvironment0(
Set<ProverOptions> options) {
throw new UnsupportedOperationException("Princess does not support optimization");
}
@Override
public String getVersion() {
return "Princess " + SimpleAPI.version();
}
@Override
public Solvers getSolverName() {
return Solvers.PRINCESS;
}
@Override
public void close() {
creator.getEnv().close();
}
@Override
protected boolean supportsAssumptionSolving() {
return false;
}
}
| 4,114 | 35.096491 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessTheoremProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import ap.api.SimpleAPI;
import ap.parser.IExpression;
import ap.parser.IFormula;
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
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.ProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
class PrincessTheoremProver extends PrincessAbstractProver<Void, IExpression>
implements ProverEnvironment {
PrincessTheoremProver(
PrincessFormulaManager pMgr,
PrincessFormulaCreator creator,
SimpleAPI pApi,
ShutdownNotifier pShutdownNotifier,
Set<ProverOptions> pOptions) {
super(pMgr, creator, pApi, pShutdownNotifier, pOptions);
}
@Override
@Nullable
public Void addConstraint(BooleanFormula constraint) {
Preconditions.checkState(!closed);
final IFormula t = (IFormula) mgr.extractInfo(constraint);
final int formulaId = addAssertedFormula(t);
if (generateUnsatCores) {
api.setPartitionNumber(formulaId);
}
addConstraint0(t);
return null;
}
@Override
protected Iterable<IExpression> getAssertedFormulas() {
return Iterables.concat(assertedFormulas);
}
}
| 1,607 | 29.339623 | 77 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/PrincessUFManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.princess;
import ap.parser.IExpression;
import ap.types.Sort;
import org.sosy_lab.java_smt.basicimpl.AbstractUFManager;
class PrincessUFManager
extends AbstractUFManager<IExpression, PrincessFunctionDeclaration, Sort, PrincessEnvironment> {
PrincessUFManager(PrincessFormulaCreator creator) {
super(creator);
}
}
| 606 | 26.590909 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/princess/package-info.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
/** Interface to the SMT solver Princess. */
@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.princess;
| 557 | 36.2 | 69 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/FormulaCollectionScript.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import static com.google.common.base.Preconditions.checkNotNull;
import de.uni_freiburg.informatik.ultimate.logic.Annotation;
import de.uni_freiburg.informatik.ultimate.logic.ApplicationTerm;
import de.uni_freiburg.informatik.ultimate.logic.Assignments;
import de.uni_freiburg.informatik.ultimate.logic.DataType;
import de.uni_freiburg.informatik.ultimate.logic.DataType.Constructor;
import de.uni_freiburg.informatik.ultimate.logic.FunctionSymbol;
import de.uni_freiburg.informatik.ultimate.logic.Logics;
import de.uni_freiburg.informatik.ultimate.logic.Model;
import de.uni_freiburg.informatik.ultimate.logic.QuotedObject;
import de.uni_freiburg.informatik.ultimate.logic.SMTLIBException;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Sort;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import de.uni_freiburg.informatik.ultimate.logic.TermVariable;
import de.uni_freiburg.informatik.ultimate.logic.Theory;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
/**
* This {@link Script} implementation allows to use the SMTLIB2 parser of SMTInterpol for parsing
* single formulas. It is meant to be given to a {@link
* de.uni_freiburg.informatik.ultimate.smtinterpol.smtlib2.ParseEnvironment} and allows declaring
* and define terms (by forwarding such calls to a real {@link Script} implementation), but does not
* allow any other actions. All formulas that are asserted (regardless of pop and push commands) are
* collected and can be retrieved afterwards.
*
* <p>The environment represented by the given {@link Script} that this class delegates to is
* changed only by declaring and defining terms, sorts etc., so these terms can be used in that
* environment afterwards.
*/
class FormulaCollectionScript implements Script {
private final Theory theory;
private final Script script;
private final List<Term> assertedTerms = new ArrayList<>(1);
FormulaCollectionScript(Script pScript, Theory pTheory) {
script = checkNotNull(pScript);
theory = checkNotNull(pTheory);
}
public List<Term> getAssertedTerms() {
return Collections.unmodifiableList(assertedTerms);
}
@Override
public LBool assertTerm(Term pTerm) throws SMTLIBException {
assertedTerms.add(pTerm);
// Do not call script.assertTerm(pTerm)
// because we do not want to actually modify the environment
return LBool.UNKNOWN;
}
@Override
public void declareFun(String fun, Sort[] paramSorts, Sort resultSort) throws SMTLIBException {
FunctionSymbol fsym = theory.getFunction(fun, paramSorts);
if (fsym == null) {
script.declareFun(fun, paramSorts, resultSort);
} else {
if (!fsym.getReturnSort().equals(resultSort)) {
throw new SMTLIBException(
"Function " + fun + " is already declared with different definition");
}
}
}
@Override
public void defineFun(String fun, TermVariable[] params, Sort resultSort, Term definition)
throws SMTLIBException {
Sort[] paramSorts = new Sort[params.length];
for (int i = 0; i < paramSorts.length; i++) {
paramSorts[i] = params[i].getSort();
}
FunctionSymbol fsym = theory.getFunction(fun, paramSorts);
if (fsym == null) {
script.defineFun(fun, params, resultSort, definition);
} else {
if (!fsym.getDefinition().equals(definition) || !fsym.getReturnSort().equals(resultSort)) {
throw new SMTLIBException(
"Function " + fun + " is already defined with different definition");
}
}
}
@Override
public void setInfo(String info, Object value) {
script.setInfo(info, value);
}
@Override
public void declareSort(String sort, int arity) throws SMTLIBException {
script.declareSort(sort, arity);
}
@Override
public void defineSort(String sort, Sort[] sortParams, Sort definition) throws SMTLIBException {
script.defineSort(sort, sortParams, definition);
}
@Override
public Sort sort(String sortname, Sort... params) throws SMTLIBException {
return script.sort(sortname, params);
}
@Override
public Sort sort(String sortname, String[] indices, Sort... params) throws SMTLIBException {
return script.sort(sortname, indices, params);
}
@Override
public Term term(String funcname, Term... params) throws SMTLIBException {
Term result = script.term(funcname, params);
return replaceWithDefinition(result);
}
@Override
public Term term(String funcname, String[] indices, Sort returnSort, Term... params)
throws SMTLIBException {
Term result = script.term(funcname, indices, returnSort, params);
return replaceWithDefinition(result);
}
private Term replaceWithDefinition(Term result) {
// Replace a term with its definition so that we do not have to handle defined terms later on.
if (result instanceof ApplicationTerm) {
FunctionSymbol func = ((ApplicationTerm) result).getFunction();
if (!func.isIntern() && func.getDefinition() != null) {
if (func.getParameterSorts().length == 0) {
result = func.getDefinition();
} else {
// If we would accept this here,
// we would need to handle the definition of a term
// when accessing its parameters with SmtInterpolUtil.getArg()
throw new SMTLIBException("Terms with definitions are not supported currently.");
}
}
}
return result;
}
@Override
public TermVariable variable(String varname, Sort sort) throws SMTLIBException {
return script.variable(varname, sort);
}
@Override
public Term quantifier(int quantor, TermVariable[] vars, Term body, Term[]... patterns)
throws SMTLIBException {
return script.quantifier(quantor, vars, body, patterns);
}
@Override
public Term let(TermVariable[] vars, Term[] values, Term body) throws SMTLIBException {
return script.let(vars, values, body);
}
@Override
public Term annotate(Term t, Annotation... annotations) throws SMTLIBException {
return script.annotate(t, annotations);
}
@Override
public Term numeral(String num) throws SMTLIBException {
return script.numeral(num);
}
@Override
public Term numeral(BigInteger num) throws SMTLIBException {
return script.numeral(num);
}
@Override
public Term decimal(String decimal) throws SMTLIBException {
return script.decimal(decimal);
}
@Override
public Term decimal(BigDecimal decimal) throws SMTLIBException {
return script.decimal(decimal);
}
@Override
public Term string(QuotedObject pStr) throws SMTLIBException {
return script.string(pStr);
}
@Override
public Term hexadecimal(String hex) throws SMTLIBException {
return script.hexadecimal(hex);
}
@Override
public Term binary(String bin) throws SMTLIBException {
return script.binary(bin);
}
@Override
public Sort[] sortVariables(String... names) throws SMTLIBException {
return script.sortVariables(names);
}
@Override
public Term[] getAssertions() throws SMTLIBException {
throw new UnsupportedOperationException();
}
@Override
public Term getProof() throws SMTLIBException, UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public Term[] getUnsatCore() throws SMTLIBException, UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public Map<Term, Term> getValue(Term[] terms)
throws SMTLIBException, UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public Assignments getAssignment() throws SMTLIBException, UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public Object getOption(String opt) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public Object getInfo(String info) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public Term simplify(Term term) throws SMTLIBException {
throw new UnsupportedOperationException();
}
@Override
public void push(int levels) {
throw new UnsupportedOperationException();
}
@Override
public void pop(int levels) throws SMTLIBException {
throw new UnsupportedOperationException();
}
@Override
public Model getModel() throws SMTLIBException, UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public void setLogic(String logic) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public void setLogic(Logics logic) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public void setOption(String opt, Object value)
throws UnsupportedOperationException, SMTLIBException {
throw new UnsupportedOperationException();
}
@Override
public void reset() {
throw new UnsupportedOperationException();
}
@Override
public Term[] getInterpolants(Term[] partition)
throws SMTLIBException, UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public Term[] getInterpolants(Term[] partition, int[] startOfSubtree)
throws SMTLIBException, UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public Term[] getInterpolants(Term[] pPartition, int[] pStartOfSubtree, Term pProofTree)
throws SMTLIBException, UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public LBool checkSat() {
throw new UnsupportedOperationException();
}
@Override
public Iterable<Term[]> checkAllsat(Term[] pPredicates) {
throw new UnsupportedOperationException();
}
@Override
public LBool checkSatAssuming(Term... pAssumptions) {
throw new UnsupportedOperationException();
}
@Override
public Term[] getUnsatAssumptions() {
throw new UnsupportedOperationException();
}
@Override
public void resetAssertions() {
throw new UnsupportedOperationException();
}
@Override
public Term[] findImpliedEquality(Term[] pX, Term[] pY) {
throw new UnsupportedOperationException();
}
@Override
public void exit() {
throw new UnsupportedOperationException();
}
@Override
public QuotedObject echo(QuotedObject pMsg) {
throw new UnsupportedOperationException();
}
@Override
public FunctionSymbol getFunctionSymbol(String pConstructor) {
throw new UnsupportedOperationException();
}
@Override
public Constructor constructor(String pName, String[] pSelectors, Sort[] pArgumentSorts)
throws SMTLIBException {
throw new UnsupportedOperationException();
}
@Override
public DataType datatype(String pTypename, int pNumParams) throws SMTLIBException {
throw new UnsupportedOperationException();
}
@Override
public void declareDatatype(DataType pDatatype, Constructor[] pConstrs) throws SMTLIBException {
throw new UnsupportedOperationException();
}
@Override
public void declareDatatypes(
DataType[] pDatatypes, Constructor[][] pConstrs, Sort[][] pSortParams)
throws SMTLIBException {
throw new UnsupportedOperationException();
}
@Override
public Term match(
Term pDataArg, TermVariable[][] pVars, Term[] pCases, Constructor[] pConstructors)
throws SMTLIBException {
throw new UnsupportedOperationException();
}
@Override
public Theory getTheory() {
return theory;
}
}
| 12,016 | 29.34596 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/LogProxyForwarder.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import static com.google.common.base.Preconditions.checkNotNull;
import de.uni_freiburg.informatik.ultimate.smtinterpol.LogProxy;
import java.util.logging.Level;
import org.sosy_lab.common.log.LogManager;
/** Implementation of {@link LogProxy} that forwards to {@link LogManager}. */
@SuppressWarnings("FormatStringAnnotation")
final class LogProxyForwarder implements LogProxy {
private static final Level LEVEL_FATAL = Level.SEVERE;
private static final Level LEVEL_ERROR = Level.WARNING;
// SMTInterpol level "warn" is too noisy for our levels "warning" or "info"
// for example because of messages "Already inconsistent." when pushing.
private static final Level LEVEL_WARN = Level.FINE;
private static final Level LEVEL_INFO = Level.FINER;
private static final Level LEVEL_DEBUG = Level.FINEST;
private static final Level LEVEL_TRACE = Level.ALL;
private final LogManager delegate;
LogProxyForwarder(LogManager pDelegate) {
delegate = checkNotNull(pDelegate);
}
@Override
public void outOfMemory(String pArg0) {
throw new OutOfMemoryError(pArg0);
}
@Override
public boolean canChangeDestination() {
return false;
}
@Override
public void changeDestination(String pArg0) {
throw new UnsupportedOperationException();
}
@Override
public String getDestination() {
return "";
}
@Override
public int getLoglevel() {
if (delegate.wouldBeLogged(LEVEL_TRACE)) {
return LogProxy.LOGLEVEL_TRACE;
} else if (delegate.wouldBeLogged(LEVEL_DEBUG)) {
return LogProxy.LOGLEVEL_DEBUG;
} else if (delegate.wouldBeLogged(LEVEL_INFO)) {
return LogProxy.LOGLEVEL_INFO;
} else if (delegate.wouldBeLogged(LEVEL_WARN)) {
return LogProxy.LOGLEVEL_WARN;
} else if (delegate.wouldBeLogged(LEVEL_ERROR)) {
return LogProxy.LOGLEVEL_ERROR;
} else if (delegate.wouldBeLogged(LEVEL_FATAL)) {
return LogProxy.LOGLEVEL_FATAL;
}
return LogProxy.LOGLEVEL_OFF;
}
@Override
public void setLoglevel(int pArg0) {
// ignore
}
@Override
public boolean isFatalEnabled() {
return delegate.wouldBeLogged(LEVEL_FATAL);
}
@Override
public boolean isErrorEnabled() {
return delegate.wouldBeLogged(LEVEL_ERROR);
}
@Override
public boolean isWarnEnabled() {
return delegate.wouldBeLogged(LEVEL_WARN);
}
@Override
public boolean isInfoEnabled() {
return delegate.wouldBeLogged(LEVEL_INFO);
}
@Override
public boolean isDebugEnabled() {
return delegate.wouldBeLogged(LEVEL_DEBUG);
}
@Override
public boolean isTraceEnabled() {
return delegate.wouldBeLogged(LEVEL_TRACE);
}
@Override
public void fatal(Object pArg0) {
delegate.log(LEVEL_FATAL, pArg0);
}
@Override
public void fatal(String pArg0, Object... pArg1) {
delegate.logf(LEVEL_FATAL, pArg0, pArg1);
}
@Override
public void error(Object pArg0) {
delegate.log(LEVEL_ERROR, pArg0);
}
@Override
public void error(String pArg0, Object... pArg1) {
delegate.logf(LEVEL_ERROR, pArg0, pArg1);
}
@Override
public void warn(Object pArg0) {
delegate.log(LEVEL_WARN, pArg0);
}
@Override
public void warn(String pArg0, Object... pArg1) {
delegate.logf(LEVEL_WARN, pArg0, pArg1);
}
@Override
public void info(Object pArg0) {
delegate.log(LEVEL_INFO, pArg0);
}
@Override
public void info(String pArg0, Object... pArg1) {
delegate.logf(LEVEL_INFO, pArg0, pArg1);
}
@Override
public void debug(Object pArg0) {
delegate.log(LEVEL_DEBUG, pArg0);
}
@Override
public void debug(String pArg0, Object... pArg1) {
delegate.logf(LEVEL_DEBUG, pArg0, pArg1);
}
@Override
public void trace(Object pArg0) {
delegate.log(LEVEL_TRACE, pArg0);
}
@Override
public void trace(String pArg0, Object... pArg1) {
delegate.logf(LEVEL_TRACE, pArg0, pArg1);
}
}
| 4,184 | 23.051724 | 78 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/LoggingSmtInterpolInterpolatingProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.Charset;
import java.nio.file.Path;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Collection;
import java.util.Deque;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.common.io.IO;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
// reason: not maintained, some implementations for methods are missing
class LoggingSmtInterpolInterpolatingProver extends SmtInterpolInterpolatingProver {
private final PrintWriter out;
LoggingSmtInterpolInterpolatingProver(
SmtInterpolFormulaManager pMgr,
Script pScript,
Set<ProverOptions> pOptions,
ShutdownNotifier pShutdownNotifier,
Map<String, Object> pGlobalOptions,
Path pLogfile) {
super(pMgr, pScript, pOptions, pShutdownNotifier);
try {
out = initializeLoggerForInterpolation(pGlobalOptions, pLogfile);
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
private PrintWriter initializeLoggerForInterpolation(
Map<String, Object> globalOptions, Path logfile) throws IOException {
@SuppressWarnings("IllegalInstantiation")
PrintWriter writer = new PrintWriter(IO.openOutputFile(logfile, Charset.defaultCharset()));
for (Map.Entry<String, Object> entry : globalOptions.entrySet()) {
writer.println(String.format("(set-option %s %s)", entry.getKey(), entry.getValue()));
}
writer.println("(set-logic " + env.getTheory().getLogic().name() + ")");
return writer;
}
@Override
public void push() {
out.println("(push 1)");
super.push();
}
@Override
public void pop() {
out.println("(pop 1)");
super.pop();
}
@Override
public String addConstraint(BooleanFormula f) {
String result = super.addConstraint(f);
out.println("(assert (! " + f + " :named " + result + "))");
return result;
}
@Override
public List<BooleanFormula> getUnsatCore() {
out.println("(get-unsat-core)");
return super.getUnsatCore();
}
@Override
public <R> R allSat(AllSatCallback<R> callback, List<BooleanFormula> predicates)
throws InterruptedException, SolverException {
out.println("(all-sat (" + Joiner.on(", ").join(predicates) + "))");
return super.allSat(callback, predicates);
}
@Override
public boolean isUnsat() throws InterruptedException {
out.print("(check-sat)");
boolean isUnsat = super.isUnsat();
out.println(" ; " + (isUnsat ? "UNSAT" : "SAT"));
return isUnsat;
}
@Override
public List<BooleanFormula> getTreeInterpolants(
List<? extends Collection<String>> partitionedTermNames, int[] startOfSubTree)
throws SolverException, InterruptedException {
Preconditions.checkArgument(partitionedTermNames.size() == startOfSubTree.length);
out.print("(get-interpolants");
Deque<Integer> subtrees = new ArrayDeque<>();
for (int i = 0; i < startOfSubTree.length; i++) {
final Collection<String> names = partitionedTermNames.get(i);
final int currentStartOfSubtree = startOfSubTree[i];
final String currentTerms;
if (names.size() == 1) {
currentTerms = names.iterator().next();
} else {
currentTerms = "(and " + Joiner.on(" ").join(names) + ")";
}
while (!subtrees.isEmpty() && subtrees.peek() > currentStartOfSubtree) {
subtrees.pop();
out.print(")");
}
out.print(" ");
if (!subtrees.isEmpty() && subtrees.peek() < currentStartOfSubtree) {
subtrees.push(currentStartOfSubtree);
out.print("(");
}
if (subtrees.isEmpty()) {
subtrees.push(currentStartOfSubtree);
}
out.print(currentTerms);
}
out.print(") ; subtrees=" + Arrays.toString(startOfSubTree));
List<BooleanFormula> result = super.getTreeInterpolants(partitionedTermNames, startOfSubTree);
out.println(" ; interpolants=" + result);
return result;
}
@Override
public void close() {
out.close();
super.close();
}
}
| 4,658 | 31.131034 | 98 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolAbstractProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import static com.google.common.base.Preconditions.checkState;
import com.google.common.collect.ImmutableMap;
import de.uni_freiburg.informatik.ultimate.logic.Annotation;
import de.uni_freiburg.informatik.ultimate.logic.FunctionSymbol;
import de.uni_freiburg.informatik.ultimate.logic.Model;
import de.uni_freiburg.informatik.ultimate.logic.ReasonUnknown;
import de.uni_freiburg.informatik.ultimate.logic.SMTLIBException;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Script.LBool;
import de.uni_freiburg.informatik.ultimate.logic.Sort;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Deque;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.common.UniqueIdGenerator;
import org.sosy_lab.common.collect.Collections3;
import org.sosy_lab.java_smt.api.BasicProverEnvironment;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
import org.sosy_lab.java_smt.basicimpl.AbstractProver;
import org.sosy_lab.java_smt.basicimpl.CachingModel;
import org.sosy_lab.java_smt.basicimpl.FormulaCreator;
@SuppressWarnings("ClassTypeParameterName")
abstract class SmtInterpolAbstractProver<T, AF> extends AbstractProver<T> {
protected boolean closed = false;
protected final Script env;
protected final FormulaCreator<Term, Sort, Script, FunctionSymbol> creator;
protected final SmtInterpolFormulaManager mgr;
protected final Deque<List<AF>> assertedFormulas = new ArrayDeque<>();
protected final Map<String, Term> annotatedTerms = new HashMap<>(); // Collection of termNames
protected final ShutdownNotifier shutdownNotifier;
private static final String PREFIX = "term_"; // for termnames
private static final UniqueIdGenerator termIdGenerator =
new UniqueIdGenerator(); // for different termnames
SmtInterpolAbstractProver(
SmtInterpolFormulaManager pMgr,
Script pEnv,
Set<ProverOptions> options,
ShutdownNotifier pShutdownNotifier) {
super(options);
mgr = pMgr;
creator = pMgr.getFormulaCreator();
env = pEnv;
shutdownNotifier = pShutdownNotifier;
assertedFormulas.push(new ArrayList<>());
}
protected boolean isClosed() {
return closed;
}
@Override
public int size() {
checkState(!closed);
return assertedFormulas.size() - 1;
}
@Override
public void push() {
checkState(!closed);
assertedFormulas.push(new ArrayList<>());
env.push(1);
}
@Override
public void pop() {
checkState(!closed);
assertedFormulas.pop();
env.pop(1);
}
@Override
public boolean isUnsat() throws InterruptedException {
checkState(!closed);
// We actually terminate SmtInterpol during the analysis
// by using a shutdown listener. However, SmtInterpol resets the
// mStopEngine flag in DPLLEngine before starting to solve,
// so we check here, too.
shutdownNotifier.shutdownIfNecessary();
LBool result = env.checkSat();
switch (result) {
case SAT:
return false;
case UNSAT:
return true;
case UNKNOWN:
Object reason = env.getInfo(":reason-unknown");
if (!(reason instanceof ReasonUnknown)) {
throw new SMTLIBException("checkSat returned UNKNOWN with unknown reason " + reason);
}
switch ((ReasonUnknown) reason) {
case MEMOUT:
// SMTInterpol catches OOM, but we want to have it thrown.
throw new OutOfMemoryError("Out of memory during SMTInterpol operation");
case CANCELLED:
shutdownNotifier.shutdownIfNecessary(); // expected if we requested termination
throw new SMTLIBException("checkSat returned UNKNOWN with unexpected reason " + reason);
default:
throw new SMTLIBException("checkSat returned UNKNOWN with unexpected reason " + reason);
}
default:
throw new SMTLIBException("checkSat returned " + result);
}
}
protected abstract Collection<Term> getAssertedTerms();
@SuppressWarnings("resource")
@Override
public org.sosy_lab.java_smt.api.Model getModel() {
checkState(!closed);
checkGenerateModels();
final Model model;
try {
model = env.getModel();
} catch (SMTLIBException e) {
if (e.getMessage().contains("Context is inconsistent")) {
throw new IllegalStateException(BasicProverEnvironment.NO_MODEL_HELP, e);
} else {
// new stacktrace, but only the library calls are missing.
throw e;
}
}
return new CachingModel(new SmtInterpolModel(this, model, creator, getAssertedTerms()));
}
protected static String generateTermName() {
return PREFIX + termIdGenerator.getFreshId();
}
@Override
public List<BooleanFormula> getUnsatCore() {
checkState(!closed);
checkGenerateUnsatCores();
return getUnsatCore0();
}
/**
* small helper method, because we guarantee that {@link
* ProverOptions#GENERATE_UNSAT_CORE_OVER_ASSUMPTIONS} is independent of {@link
* ProverOptions#GENERATE_UNSAT_CORE}.
*/
private List<BooleanFormula> getUnsatCore0() {
return Collections3.transformedImmutableListCopy(
env.getUnsatCore(),
input -> creator.encapsulateBoolean(annotatedTerms.get(input.toString())));
}
@Override
public Optional<List<BooleanFormula>> unsatCoreOverAssumptions(
Collection<BooleanFormula> assumptions) throws InterruptedException {
checkState(!closed);
checkGenerateUnsatCoresOverAssumptions();
push();
checkState(
annotatedTerms.isEmpty(),
"Empty environment required for UNSAT core over assumptions: %s",
annotatedTerms);
for (BooleanFormula assumption : assumptions) {
String termName = generateTermName();
Term t = mgr.extractInfo(assumption);
Term annotated = env.annotate(t, new Annotation(":named", termName));
annotatedTerms.put(termName, t);
env.assertTerm(annotated);
}
Optional<List<BooleanFormula>> result =
isUnsat() ? Optional.of(getUnsatCore0()) : Optional.empty();
pop();
return result;
}
@Override
public ImmutableMap<String, String> getStatistics() {
ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
SmtInterpolSolverContext.flatten(builder, "", env.getInfo(":all-statistics"));
return builder.buildOrThrow();
}
@Override
public void close() {
if (!closed) {
assertedFormulas.clear();
annotatedTerms.clear();
env.pop(assertedFormulas.size());
closed = true;
}
}
@Override
public boolean isUnsatWithAssumptions(Collection<BooleanFormula> pAssumptions)
throws SolverException, InterruptedException {
throw new UnsupportedOperationException("Assumption-solving is not supported.");
}
@Override
public <R> R allSat(AllSatCallback<R> callback, List<BooleanFormula> important)
throws InterruptedException, SolverException {
checkState(!closed);
checkGenerateAllSat();
Term[] importantTerms = new Term[important.size()];
int i = 0;
for (BooleanFormula impF : important) {
importantTerms[i++] = mgr.extractInfo(impF);
}
// We actually terminate SmtInterpol during the analysis
// by using a shutdown listener. However, SmtInterpol resets the
// mStopEngine flag in DPLLEngine before starting to solve,
// so we check here, too.
shutdownNotifier.shutdownIfNecessary();
for (Term[] model : env.checkAllsat(importantTerms)) {
callback.apply(Collections3.transformedImmutableListCopy(model, creator::encapsulateBoolean));
}
return callback.getResult();
}
}
| 8,249 | 32.950617 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolArrayFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import de.uni_freiburg.informatik.ultimate.logic.FunctionSymbol;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Sort;
import de.uni_freiburg.informatik.ultimate.logic.Term;
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;
class SmtInterpolArrayFormulaManager
extends AbstractArrayFormulaManager<Term, Sort, Script, FunctionSymbol> {
private final Script env;
SmtInterpolArrayFormulaManager(SmtInterpolFormulaCreator pCreator) {
super(pCreator);
env = pCreator.getEnv();
}
@Override
protected Term select(Term pArray, Term pIndex) {
return env.term("select", pArray, pIndex);
}
@Override
protected Term store(Term pArray, Term pIndex, Term pValue) {
return env.term("store", pArray, pIndex, pValue);
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TI extends Formula, TE extends Formula> Term internalMakeArray(
String pName, FormulaType<TI> pIndexType, FormulaType<TE> pElementType) {
final ArrayFormulaType<TI, TE> arrayFormulaType =
FormulaType.getArrayType(pIndexType, pElementType);
final Sort smtInterpolArrayType = toSolverType(arrayFormulaType);
return getFormulaCreator().makeVariable(smtInterpolArrayType, pName);
}
@Override
protected Term equivalence(Term pArray1, Term pArray2) {
return env.term("=", pArray1, pArray2);
}
}
| 1,868 | 31.789474 | 79 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolBooleanFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import de.uni_freiburg.informatik.ultimate.logic.FunctionSymbol;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Sort;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import de.uni_freiburg.informatik.ultimate.logic.Theory;
import java.util.Collection;
import org.sosy_lab.java_smt.basicimpl.AbstractBooleanFormulaManager;
class SmtInterpolBooleanFormulaManager
extends AbstractBooleanFormulaManager<Term, Sort, Script, FunctionSymbol> {
// We use the Theory directly here because the methods there perform simplifications
// that we could not use otherwise.
private final Theory theory;
SmtInterpolBooleanFormulaManager(SmtInterpolFormulaCreator creator) {
super(creator);
theory = getFormulaCreator().getEnv().getTheory();
}
@Override
public Term makeVariableImpl(String varName) {
return formulaCreator.makeVariable(formulaCreator.getBoolType(), varName);
}
@Override
public Term makeBooleanImpl(boolean pValue) {
Term t;
if (pValue) {
t = theory.mTrue;
} else {
t = theory.mFalse;
}
return t;
}
@Override
public Term equivalence(Term t1, Term t2) {
assert t1.getTheory().getBooleanSort() == t1.getSort()
&& t2.getTheory().getBooleanSort() == t2.getSort()
: "Cannot make equivalence of non-boolean terms:\nTerm 1:\n"
+ t1.toStringDirect()
+ "\nTerm 2:\n"
+ t2.toStringDirect();
return theory.equals(t1, t2);
}
@Override
public boolean isTrue(Term t) {
return t.getTheory().mTrue == t;
}
@Override
public boolean isFalse(Term t) {
return t.getTheory().mFalse == t;
}
@Override
public Term ifThenElse(Term condition, Term t1, Term t2) {
return theory.ifthenelse(condition, t1, t2);
}
@Override
public Term not(Term pBits) {
return theory.not(pBits);
}
@Override
public Term and(Term pBits1, Term pBits2) {
return theory.and(pBits1, pBits2);
}
@Override
protected Term andImpl(Collection<Term> pParams) {
// SMTInterpol does all simplifications itself
return theory.and(pParams.toArray(new Term[0]));
}
@Override
public Term or(Term pBits1, Term pBits2) {
return theory.or(pBits1, pBits2);
}
@Override
protected Term orImpl(Collection<Term> pParams) {
// SMTInterpol does all simplifications itself
return theory.or(pParams.toArray(new Term[0]));
}
@Override
public Term xor(Term pBits1, Term pBits2) {
return theory.xor(pBits1, pBits2);
}
@Override
protected Term implication(Term bits1, Term bits2) {
return theory.implies(bits1, bits2);
}
}
| 2,965 | 25.963636 | 86 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolFormulaCreator.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import static com.google.common.base.Preconditions.checkArgument;
import static org.sosy_lab.common.collect.Collections3.transformedImmutableListCopy;
import com.google.common.collect.ImmutableSet;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import de.uni_freiburg.informatik.ultimate.logic.ApplicationTerm;
import de.uni_freiburg.informatik.ultimate.logic.ConstantTerm;
import de.uni_freiburg.informatik.ultimate.logic.FunctionSymbol;
import de.uni_freiburg.informatik.ultimate.logic.NoopScript;
import de.uni_freiburg.informatik.ultimate.logic.Rational;
import de.uni_freiburg.informatik.ultimate.logic.SMTLIBException;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Sort;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import de.uni_freiburg.informatik.ultimate.logic.Theory;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import org.sosy_lab.java_smt.api.ArrayFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.FunctionDeclarationKind;
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;
class SmtInterpolFormulaCreator extends FormulaCreator<Term, Sort, Script, FunctionSymbol> {
/** SMTInterpol does not allow using key-functions as identifiers. */
private static final ImmutableSet<String> UNSUPPORTED_IDENTIFIERS =
ImmutableSet.of("true", "false", "select", "store", "or", "and", "xor", "distinct");
SmtInterpolFormulaCreator(final Script env) {
super(
env,
env.getTheory().getBooleanSort(),
env.getTheory().getNumericSort(),
env.getTheory().getRealSort(),
null,
null);
}
@Override
public FormulaType<?> getFormulaType(final Term pFormula) {
return getFormulaTypeOfSort(pFormula.getSort());
}
private FormulaType<?> getFormulaTypeOfSort(final Sort pSort) {
if (pSort == getIntegerType()) {
return FormulaType.IntegerType;
} else if (pSort == getRationalType()) {
return FormulaType.RationalType;
} else if (pSort == getBoolType()) {
return FormulaType.BooleanType;
} else if (pSort.isArraySort()) {
return FormulaType.getArrayType(
getFormulaTypeOfSort(pSort.getArguments()[0]),
getFormulaTypeOfSort(pSort.getArguments()[1]));
} else {
throw new IllegalArgumentException("Unknown formula type for sort: " + pSort);
}
}
@SuppressWarnings("unchecked")
@Override
public <T extends Formula> FormulaType<T> getFormulaType(final T pFormula) {
if (pFormula instanceof ArrayFormula<?, ?>) {
final FormulaType<?> arrayIndexType = getArrayFormulaIndexType((ArrayFormula<?, ?>) pFormula);
final FormulaType<?> arrayElementType =
getArrayFormulaElementType((ArrayFormula<?, ?>) pFormula);
return (FormulaType<T>) FormulaType.getArrayType(arrayIndexType, arrayElementType);
}
return super.getFormulaType(pFormula);
}
@Override
public Term makeVariable(final Sort type, final String varName) {
declareFun(varName, new Sort[] {}, type);
return environment.term(varName);
}
/**
* This function declares a new functionSymbol, that has a given (result-) sort. The params for
* the functionSymbol also have sorts. If you want to declare a new variable, i.e. "X", paramSorts
* is an empty array.
*/
@CanIgnoreReturnValue
private FunctionSymbol declareFun(String fun, Sort[] paramSorts, Sort resultSort) {
checkSymbol(fun);
FunctionSymbol fsym = environment.getTheory().getFunction(fun, paramSorts);
if (fsym == null) {
environment.declareFun(fun, paramSorts, resultSort);
return environment.getTheory().getFunction(fun, paramSorts);
} else {
if (!fsym.getReturnSort().equals(resultSort)) {
throw new IllegalArgumentException(
"Function " + fun + " is already declared with different definition");
}
if (fun.equals("true") || fun.equals("false")) {
throw new IllegalArgumentException("Cannot declare a variable named " + fun);
}
return fsym;
}
}
/**
* Copied from {@link NoopScript#checkSymbol}.
*
* <p>Check that the symbol does not contain characters that would make it impossible to use it in
* a LoggingScript. These are | and \.
*
* @param symbol the symbol to check
* @throws IllegalArgumentException if symbol contains | or \.
*/
private void checkSymbol(String symbol) throws SMTLIBException {
checkArgument(
symbol.indexOf('|') == -1 && symbol.indexOf('\\') == -1, "Symbol must not contain | or \\");
checkArgument(
!UNSUPPORTED_IDENTIFIERS.contains(symbol),
"SMTInterpol does not support %s as identifier.",
symbol);
}
@Override
public Sort getBitvectorType(final int pBitwidth) {
throw new UnsupportedOperationException(
"Bitvector theory is not supported " + "by SmtInterpol");
}
@Override
public Sort getFloatingPointType(final FormulaType.FloatingPointType type) {
throw new UnsupportedOperationException(
"FloatingPoint theory is not " + "supported by SmtInterpol");
}
@Override
public Sort getArrayType(final Sort pIndexType, final Sort pElementType) {
return getEnv().getTheory().getSort("Array", pIndexType, pElementType);
}
/** convert a boolean or numeral term into an object of type Boolean, BigInteger, or Rational. */
@Override
public Object convertValue(Term value) {
FormulaType<?> type = getFormulaType(value);
if (type.isBooleanType()) {
return value.getTheory().mTrue == value;
} else if (value instanceof ConstantTerm
&& ((ConstantTerm) value).getValue() instanceof Rational) {
/*
* From SmtInterpol documentation (see {@link ConstantTerm#getValue}),
* the output is SmtInterpol's Rational unless it is a bitvector,
* and currently we do not support bitvectors for SmtInterpol.
*/
Rational rationalValue = (Rational) ((ConstantTerm) value).getValue();
org.sosy_lab.common.rationals.Rational ratValue =
org.sosy_lab.common.rationals.Rational.of(
rationalValue.numerator(), rationalValue.denominator());
return ratValue.isIntegral() ? ratValue.getNum() : ratValue;
} else {
throw new IllegalArgumentException("Unexpected value: " + value);
}
}
/** ApplicationTerms can be wrapped with "|". This function removes those chars. */
public static String dequote(String s) {
int l = s.length();
if (s.charAt(0) == '|' && s.charAt(l - 1) == '|') {
return s.substring(1, l - 1);
}
return s;
}
@Override
public <R> R visit(FormulaVisitor<R> visitor, Formula f, final Term input) {
checkArgument(
input.getTheory().equals(environment.getTheory()),
"Given term belongs to a different instance of SMTInterpol: %s",
input);
if (input instanceof ConstantTerm) {
Object outValue;
Object interpolValue = ((ConstantTerm) input).getValue();
if (interpolValue instanceof Rational) {
Rational rat = (Rational) interpolValue;
if ((input.getSort().getName().equals("Int") && rat.isIntegral())
|| BigInteger.ONE.equals(rat.denominator())) {
outValue = rat.numerator();
} else {
outValue = org.sosy_lab.common.rationals.Rational.of(rat.numerator(), rat.denominator());
}
} else {
outValue = ((ConstantTerm) input).getValue();
}
return visitor.visitConstant(f, outValue);
} else if (input instanceof ApplicationTerm) {
final ApplicationTerm app = (ApplicationTerm) input;
final int arity = app.getParameters().length;
final FunctionSymbol func = app.getFunction();
if (arity == 0) {
if (app.equals(environment.getTheory().mTrue)) {
return visitor.visitConstant(f, Boolean.TRUE);
} else if (app.equals(environment.getTheory().mFalse)) {
return visitor.visitConstant(f, Boolean.FALSE);
} else if (func.getDefinition() == null) {
return visitor.visitFreeVariable(f, dequote(input.toString()));
} else {
throw new UnsupportedOperationException("Unexpected nullary function " + input);
}
} else {
final String name = func.getName();
List<Formula> args =
transformedImmutableListCopy(
app.getParameters(), term -> encapsulate(getFormulaType(term), term));
final List<FormulaType<?>> argTypes;
final Term definition = func.getDefinition();
if (definition == null) { // generic function application, e.g., EQUALS
argTypes = transformedImmutableListCopy(args, this::getFormulaType);
} else {
Sort[] paramSorts = ((ApplicationTerm) definition).getFunction().getParameterSorts();
argTypes = transformedImmutableListCopy(paramSorts, this::getFormulaTypeOfSort);
}
// Any function application.
return visitor.visitFunction(
f,
args,
FunctionDeclarationImpl.of(
name, getDeclarationKind(app), argTypes, getFormulaType(f), app.getFunction()));
}
} else {
// TODO: support for quantifiers and bound variables
throw new UnsupportedOperationException(
String.format(
"Unexpected SMTInterpol formula of type %s: %s",
input.getClass().getSimpleName(), input));
}
}
String getName(Term t) {
if (isUF(t)) {
assert t instanceof ApplicationTerm;
return ((ApplicationTerm) t).getFunction().getName();
} else {
return dequote(t.toString());
}
}
private static boolean isVariable(Term t) {
// A variable is the same as an UF without parameters
return t.getTheory().mTrue != t
&& t.getTheory().mFalse != t
&& (t instanceof ApplicationTerm)
&& ((ApplicationTerm) t).getParameters().length == 0
&& ((ApplicationTerm) t).getFunction().getDefinition() == null;
}
private static boolean isUF(Term t) {
if (!(t instanceof ApplicationTerm)) {
return false;
}
ApplicationTerm applicationTerm = (ApplicationTerm) t;
FunctionSymbol func = applicationTerm.getFunction();
return applicationTerm.getParameters().length > 0 && !func.isIntern() && !func.isInterpreted();
}
private FunctionDeclarationKind getDeclarationKind(ApplicationTerm input) {
assert !isVariable(input) : "Variables should be handled somewhere else";
FunctionSymbol symbol = input.getFunction();
Theory t = input.getTheory();
if (isUF(input)) {
return FunctionDeclarationKind.UF;
} else if (symbol == t.mAnd) {
return FunctionDeclarationKind.AND;
} else if (symbol == t.mOr) {
return FunctionDeclarationKind.OR;
} else if (symbol == t.mNot) {
return FunctionDeclarationKind.NOT;
} else if (symbol == t.mImplies) {
return FunctionDeclarationKind.IMPLIES;
} else if (symbol == t.mXor) {
return FunctionDeclarationKind.XOR;
}
// Polymorphic function symbols are more difficult.
switch (symbol.getName()) {
case "=":
return FunctionDeclarationKind.EQ;
case "distinct":
return FunctionDeclarationKind.DISTINCT;
case "ite":
return FunctionDeclarationKind.ITE;
case "select":
return FunctionDeclarationKind.SELECT;
case "store":
return FunctionDeclarationKind.STORE;
case "*":
return FunctionDeclarationKind.MUL;
case "+":
return FunctionDeclarationKind.ADD;
case "-":
return FunctionDeclarationKind.SUB;
case "/":
case "div":
return FunctionDeclarationKind.DIV;
case "%":
case "mod":
return FunctionDeclarationKind.MODULO;
case "<":
return FunctionDeclarationKind.LT;
case "<=":
return FunctionDeclarationKind.LTE;
case ">":
return FunctionDeclarationKind.GT;
case ">=":
return FunctionDeclarationKind.GTE;
case "to_int":
return FunctionDeclarationKind.FLOOR;
case "to_real":
return FunctionDeclarationKind.TO_REAL;
default:
// TODO: other declaration kinds!
return FunctionDeclarationKind.OTHER;
}
}
@Override
public FunctionSymbol declareUFImpl(String pName, Sort returnType, List<Sort> pArgs) {
Sort[] types = pArgs.toArray(new Sort[0]);
return declareFun(pName, types, returnType);
}
@Override
public Term callFunctionImpl(FunctionSymbol declaration, List<Term> args) {
// add an explicit cast from INT to RATIONAL if needed
final List<Term> castedArgs = new ArrayList<>();
for (int i = 0; i < args.size(); i++) {
// for chainable functions like EQ, DISTINCT, ADD, we repeat the last argument-type
int index = Math.min(i, declaration.getParameterSorts().length - 1);
Term arg = args.get(i);
Sort argSort = arg.getSort();
Sort paramSort = declaration.getParameterSorts()[index];
if (getRationalType() == paramSort && getIntegerType() == argSort) {
arg = environment.term("to_real", arg);
}
castedArgs.add(arg);
}
return environment.term(declaration.getName(), castedArgs.toArray(new Term[0]));
}
@Override
protected FunctionSymbol getBooleanVarDeclarationImpl(Term pTerm) {
assert pTerm instanceof ApplicationTerm;
return ((ApplicationTerm) pTerm).getFunction();
}
}
| 14,001 | 36.239362 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import static com.google.common.collect.Iterables.getOnlyElement;
import de.uni_freiburg.informatik.ultimate.logic.AnnotatedTerm;
import de.uni_freiburg.informatik.ultimate.logic.ApplicationTerm;
import de.uni_freiburg.informatik.ultimate.logic.FormulaLet;
import de.uni_freiburg.informatik.ultimate.logic.FormulaUnLet;
import de.uni_freiburg.informatik.ultimate.logic.FunctionSymbol;
import de.uni_freiburg.informatik.ultimate.logic.PrintTerm;
import de.uni_freiburg.informatik.ultimate.logic.SMTLIBException;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Sort;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import de.uni_freiburg.informatik.ultimate.logic.simplification.SimplifyDDA;
import de.uni_freiburg.informatik.ultimate.smtinterpol.LogProxy;
import de.uni_freiburg.informatik.ultimate.smtinterpol.option.OptionMap;
import de.uni_freiburg.informatik.ultimate.smtinterpol.smtlib2.ParseEnvironment;
import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayDeque;
import java.util.Collections;
import java.util.Deque;
import java.util.HashSet;
import java.util.Set;
import org.sosy_lab.common.Appender;
import org.sosy_lab.common.Appenders;
import org.sosy_lab.common.log.LogManager;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.basicimpl.AbstractFormulaManager;
public class SmtInterpolFormulaManager
extends AbstractFormulaManager<Term, Sort, Script, FunctionSymbol> {
private final LogManager logger;
SmtInterpolFormulaManager(
SmtInterpolFormulaCreator pCreator,
SmtInterpolUFManager pFunctionManager,
SmtInterpolBooleanFormulaManager pBooleanManager,
SmtInterpolIntegerFormulaManager pIntegerManager,
SmtInterpolRationalFormulaManager pRationalManager,
SmtInterpolArrayFormulaManager pArrayFormulaManager,
LogManager pLogger) {
super(
pCreator,
pFunctionManager,
pBooleanManager,
pIntegerManager,
pRationalManager,
null,
null,
null,
pArrayFormulaManager,
null,
null,
null);
logger = pLogger;
}
BooleanFormula encapsulateBooleanFormula(Term t) {
return getFormulaCreator().encapsulateBoolean(t);
}
@Override
public BooleanFormula parse(String pS) throws IllegalArgumentException {
FormulaCollectionScript parseScript =
new FormulaCollectionScript(getEnvironment(), getEnvironment().getTheory());
LogProxy logProxy = new LogProxyForwarder(logger.withComponentName("SMTInterpol"));
final ParseEnvironment parseEnv =
new ParseEnvironment(parseScript, new OptionMap(logProxy, true)) {
@Override
public void printError(String pMessage) {
throw new SMTLIBException(pMessage);
}
@Override
public void printSuccess() {}
};
try {
parseEnv.parseStream(new StringReader(pS), "<stdin>");
} catch (SMTLIBException nested) {
throw new IllegalArgumentException(nested);
}
Term term = getOnlyElement(parseScript.getAssertedTerms());
return encapsulateBooleanFormula(new FormulaUnLet().unlet(term));
}
@Override
public Appender dumpFormula(final Term formula) {
assert getFormulaCreator().getFormulaType(formula) == FormulaType.BooleanType
: "Only BooleanFormulas may be dumped";
return new Appenders.AbstractAppender() {
@Override
public void appendTo(Appendable out) throws IOException {
Set<Term> seen = new HashSet<>();
Set<FunctionSymbol> declaredFunctions = new HashSet<>();
Deque<Term> todo = new ArrayDeque<>();
PrintTerm termPrinter = new PrintTerm();
todo.addLast(formula);
while (!todo.isEmpty()) {
Term t = todo.removeLast();
while (t instanceof AnnotatedTerm) {
t = ((AnnotatedTerm) t).getSubterm();
}
if (!(t instanceof ApplicationTerm) || !seen.add(t)) {
continue;
}
ApplicationTerm term = (ApplicationTerm) t;
Collections.addAll(todo, term.getParameters());
FunctionSymbol func = term.getFunction();
if (func.isIntern()) {
continue;
}
if (func.getDefinition() == null) {
if (declaredFunctions.add(func)) {
out.append("(declare-fun ");
out.append(PrintTerm.quoteIdentifier(func.getName()));
out.append(" (");
int counter = 0;
for (Sort paramSort : func.getParameterSorts()) {
termPrinter.append(out, paramSort);
if (++counter < func.getParameterSorts().length) {
out.append(' ');
}
}
out.append(") ");
termPrinter.append(out, func.getReturnSort());
out.append(")\n");
}
} else {
// We would have to print a (define-fun) command and
// recursively traverse into func.getDefinition() (in post-order!).
// However, such terms should actually not occur.
throw new IllegalArgumentException("Terms with definition are unsupported.");
}
}
out.append("(assert ");
// This is the same as t.toString() does,
// but directly uses the Appendable for better performance
// and less memory consumption.
Term letted = new FormulaLet().let(formula);
termPrinter.append(out, letted);
out.append(")");
}
};
}
@Override
public Term simplify(Term pF) {
SimplifyDDA s = new SimplifyDDA(getEnvironment(), true);
return s.getSimplifiedTerm(pF);
}
}
| 6,117 | 33.564972 | 89 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolIntegerFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import de.uni_freiburg.informatik.ultimate.logic.Sort;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import java.math.BigDecimal;
import java.math.BigInteger;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
class SmtInterpolIntegerFormulaManager
extends SmtInterpolNumeralFormulaManager<IntegerFormula, IntegerFormula>
implements IntegerFormulaManager {
SmtInterpolIntegerFormulaManager(
SmtInterpolFormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
}
@Override
protected Term makeNumberImpl(long i) {
return env.numeral(BigInteger.valueOf(i));
}
@Override
protected Term makeNumberImpl(BigInteger pI) {
return env.numeral(pI);
}
@Override
protected Term makeNumberImpl(String pI) {
return env.numeral(pI);
}
@Override
protected Term makeNumberImpl(double pNumber) {
return makeNumberImpl((long) pNumber);
}
@Override
protected Term makeNumberImpl(BigDecimal pNumber) {
return decimalAsInteger(pNumber);
}
@Override
protected Term makeVariableImpl(String varName) {
Sort t = getFormulaCreator().getIntegerType();
return getFormulaCreator().makeVariable(t, varName);
}
@Override
public Term divide(Term pNumber1, Term pNumber2) {
if (consistsOfNumerals(pNumber2)) {
Sort intSort = pNumber1.getTheory().getNumericSort();
assert intSort.equals(pNumber1.getSort()) && intSort.equals(pNumber2.getSort());
return env.term("div", pNumber1, pNumber2);
} else {
return super.divide(pNumber1, pNumber2);
}
}
@Override
protected Term modulo(Term pNumber1, Term pNumber2) {
if (consistsOfNumerals(pNumber2)) {
Sort intSort = pNumber1.getTheory().getNumericSort();
assert intSort.equals(pNumber1.getSort()) && intSort.equals(pNumber2.getSort());
return env.term("mod", pNumber1, pNumber2);
} else {
return super.modulo(pNumber1, pNumber2);
}
}
@Override
protected Term modularCongruence(Term pNumber1, Term pNumber2, BigInteger pModulo) {
return modularCongruence0(pNumber1, pNumber2, env.numeral(pModulo));
}
@Override
protected Term modularCongruence(Term pNumber1, Term pNumber2, long pModulo) {
return modularCongruence0(pNumber1, pNumber2, env.numeral(BigInteger.valueOf(pModulo)));
}
protected Term modularCongruence0(Term pNumber1, Term pNumber2, Term n) {
Sort intSort = pNumber1.getTheory().getNumericSort();
assert intSort.equals(pNumber1.getSort()) && intSort.equals(pNumber2.getSort());
// ((_ divisible n) x) <==> (= x (* n (div x n)))
Term x = subtract(pNumber1, pNumber2);
return env.term("=", x, env.term("*", n, env.term("div", x, n)));
}
}
| 3,107 | 30.393939 | 92 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolInterpolatingProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import de.uni_freiburg.informatik.ultimate.logic.Annotation;
import de.uni_freiburg.informatik.ultimate.logic.SMTLIBException;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
class SmtInterpolInterpolatingProver extends SmtInterpolAbstractProver<String, String>
implements InterpolatingProverEnvironment<String> {
SmtInterpolInterpolatingProver(
SmtInterpolFormulaManager pMgr,
Script pScript,
Set<ProverOptions> options,
ShutdownNotifier pShutdownNotifier) {
super(pMgr, pScript, options, pShutdownNotifier);
}
@Override
public void pop() {
Preconditions.checkState(!closed);
for (String removed : assertedFormulas.peek()) {
annotatedTerms.remove(removed);
}
super.pop();
}
@Override
public String addConstraint(BooleanFormula f) {
Preconditions.checkState(!closed);
String termName = generateTermName();
Term t = mgr.extractInfo(f);
Term annotatedTerm = env.annotate(t, new Annotation(":named", termName));
env.assertTerm(annotatedTerm);
assertedFormulas.peek().add(termName);
annotatedTerms.put(termName, t);
return termName;
}
@Override
public BooleanFormula getInterpolant(Collection<String> pTermNamesOfA)
throws SolverException, InterruptedException {
Preconditions.checkState(!closed);
// SMTInterpol is not able to handle the trivial cases,
// so we need to check them explicitly
if (pTermNamesOfA.isEmpty()) {
return mgr.getBooleanFormulaManager().makeBoolean(true);
} else if (pTermNamesOfA.containsAll(annotatedTerms.keySet())) {
return mgr.getBooleanFormulaManager().makeBoolean(false);
}
Set<String> termNamesOfA = ImmutableSet.copyOf(pTermNamesOfA);
// calc difference: termNamesOfB := assertedFormulas - termNamesOfA
Set<String> termNamesOfB =
annotatedTerms.keySet().stream()
.filter(n -> !termNamesOfA.contains(n))
.collect(ImmutableSet.toImmutableSet());
// build 2 groups: (and A1 A2 A3...) , (and B1 B2 B3...)
return Iterables.getOnlyElement(
getSeqInterpolants(ImmutableList.of(termNamesOfA, termNamesOfB)));
}
@Override
public List<BooleanFormula> getTreeInterpolants(
List<? extends Collection<String>> partitionedTermNames, int[] startOfSubTree)
throws SolverException, InterruptedException {
Preconditions.checkState(!closed);
assert InterpolatingProverEnvironment.checkTreeStructure(
partitionedTermNames.size(), startOfSubTree);
final Term[] formulas = new Term[partitionedTermNames.size()];
for (int i = 0; i < formulas.length; i++) {
formulas[i] = buildConjunctionOfNamedTerms(partitionedTermNames.get(i));
}
// get interpolants of groups
final Term[] itps;
try {
itps = env.getInterpolants(formulas, startOfSubTree);
} catch (UnsupportedOperationException e) {
if (e.getMessage() != null && e.getMessage().startsWith("Cannot interpolate ")) {
// Not a bug, interpolation procedure is incomplete
throw new SolverException(e.getMessage(), e);
} else {
throw e;
}
} catch (SMTLIBException e) {
if ("Timeout exceeded".equals(e.getMessage())) {
shutdownNotifier.shutdownIfNecessary();
}
throw new AssertionError(e);
}
final List<BooleanFormula> result = new ArrayList<>();
for (Term itp : itps) {
result.add(mgr.encapsulateBooleanFormula(itp));
}
assert result.size() == startOfSubTree.length - 1;
return result;
}
private Term buildConjunctionOfNamedTerms(Collection<String> termNames) {
Preconditions.checkState(!closed);
Preconditions.checkArgument(!termNames.isEmpty());
if (termNames.size() == 1) {
return env.term(Iterables.getOnlyElement(termNames));
}
return env.term("and", termNames.stream().map(env::term).toArray(Term[]::new));
}
@Override
protected Collection<Term> getAssertedTerms() {
return annotatedTerms.values();
}
}
| 4,918 | 33.886525 | 87 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolModel.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import de.uni_freiburg.informatik.ultimate.logic.ApplicationTerm;
import de.uni_freiburg.informatik.ultimate.logic.FunctionSymbol;
import de.uni_freiburg.informatik.ultimate.logic.Model;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Sort;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import de.uni_freiburg.informatik.ultimate.smtinterpol.model.FunctionValue.Index;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import org.sosy_lab.java_smt.basicimpl.AbstractModel;
import org.sosy_lab.java_smt.basicimpl.AbstractProver;
import org.sosy_lab.java_smt.basicimpl.FormulaCreator;
class SmtInterpolModel extends AbstractModel<Term, Sort, Script> {
private final Model model;
private final Script env;
private final ImmutableList<Term> assertedTerms;
SmtInterpolModel(
AbstractProver<?> pProver,
Model pModel,
FormulaCreator<Term, Sort, Script, ?> pCreator,
Collection<Term> pAssertedTerms) {
super(pProver, pCreator);
model = pModel;
env = pCreator.getEnv();
assertedTerms = ImmutableList.copyOf(pAssertedTerms);
}
@Override
public ImmutableList<ValueAssignment> asList() {
Set<FunctionSymbol> usedSymbols = new LinkedHashSet<>();
for (Term assertedTerm : assertedTerms) {
for (Term symbol : creator.extractVariablesAndUFs(assertedTerm, true).values()) {
if (symbol instanceof ApplicationTerm) {
usedSymbols.add(((ApplicationTerm) symbol).getFunction());
}
}
}
ImmutableSet.Builder<ValueAssignment> assignments = ImmutableSet.builder();
for (FunctionSymbol symbol : model.getDefinedFunctions()) {
// SMTInterpol also reports evaluations for unused symbols, including those from different
// prover stacks. Thus, we ignore unused symbols. Those symbols are still shown when
// applying model.toString().
if (!usedSymbols.contains(symbol)) {
continue;
}
final String name = unescape(symbol.getApplicationString());
if (symbol.getParameterSorts().length == 0) { // simple variable or array
Term variable = env.term(name);
if (symbol.getReturnSort().isArraySort()) {
assignments.addAll(getArrayAssignment(name, variable, variable, ImmutableList.of()));
} else {
assignments.add(getAssignment(name, (ApplicationTerm) variable));
}
} else { // uninterpreted function
assignments.addAll(getUFAssignments(symbol));
}
}
return assignments.build().asList();
}
private static String unescape(String s) {
return s.startsWith("|") ? s.substring(1, s.length() - 1) : s;
}
/**
* Get all modeled assignments for the given array.
*
* @param symbol name of the array
* @param key term of the whole array, such that a select operation returns the evaluation,
* @param array term of the array, such that an evaluation returns its whole content
* @param upperIndices indices for multi-dimensional arrays
*/
private Collection<ValueAssignment> getArrayAssignment(
String symbol, Term key, Term array, List<Object> upperIndices) {
assert array.getSort().isArraySort();
Collection<ValueAssignment> assignments = new ArrayList<>();
Term evaluation = model.evaluate(array);
// get all assignments for the current array
while (evaluation instanceof ApplicationTerm) {
ApplicationTerm arrayEval = (ApplicationTerm) evaluation;
FunctionSymbol funcDecl = arrayEval.getFunction();
Term[] params = arrayEval.getParameters();
if (funcDecl.isIntern() && "store".equals(funcDecl.getName())) {
Term index = params[1];
Term content = params[2];
List<Object> innerIndices = new ArrayList<>(upperIndices);
innerIndices.add(evaluateImpl(index));
Term select = env.term("select", key, index);
if (content.getSort().isArraySort()) {
assignments.addAll(getArrayAssignment(symbol, select, content, innerIndices));
} else {
assignments.add(
new ValueAssignment(
creator.encapsulateWithTypeOf(select),
creator.encapsulateWithTypeOf(model.evaluate(content)),
creator.encapsulateBoolean(env.term("=", select, content)),
symbol,
evaluateImpl(content),
innerIndices));
}
evaluation = params[0]; // unwrap recursive for more values
} else {
// we found the basis of the array
break;
}
}
return assignments;
}
/** Get all modeled assignments for the UF. */
private Collection<ValueAssignment> getUFAssignments(FunctionSymbol symbol) {
final Collection<ValueAssignment> assignments = new ArrayList<>();
final String name = unescape(symbol.getApplicationString());
// direct interaction with internal classes and internal behaviour of SMTInterpol.
// they made some classes 'public' especially for us,
// because there is no nicer way of iterating over UF-assignments,
// except building an ITE-formula in SMTInterpol and splitting it here (alternative solution).
de.uni_freiburg.informatik.ultimate.smtinterpol.model.Model mmodel =
(de.uni_freiburg.informatik.ultimate.smtinterpol.model.Model) model;
for (Index key : mmodel.getFunctionValue(symbol).values().keySet()) {
assignments.add(getAssignment(name, (ApplicationTerm) env.term(name, key.toArray())));
}
return assignments;
}
private ValueAssignment getAssignment(String key, ApplicationTerm term) {
Term value = model.evaluate(term);
List<Object> argumentInterpretation = new ArrayList<>();
for (Term param : term.getParameters()) {
argumentInterpretation.add(evaluateImpl(param));
}
return new ValueAssignment(
creator.encapsulateWithTypeOf(term),
creator.encapsulateWithTypeOf(value),
creator.encapsulateBoolean(env.term("=", term, value)),
key,
evaluateImpl(term),
argumentInterpretation);
}
@Override
public String toString() {
return model.toString();
}
@Override
public void close() {}
@Override
protected Term evalImpl(Term formula) {
return model.evaluate(formula);
}
}
| 6,790 | 35.12234 | 98 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolNumeralFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import com.google.common.collect.ImmutableSet;
import de.uni_freiburg.informatik.ultimate.logic.ApplicationTerm;
import de.uni_freiburg.informatik.ultimate.logic.ConstantTerm;
import de.uni_freiburg.informatik.ultimate.logic.FunctionSymbol;
import de.uni_freiburg.informatik.ultimate.logic.Rational;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Sort;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.sosy_lab.java_smt.api.NumeralFormula;
import org.sosy_lab.java_smt.basicimpl.AbstractNumeralFormulaManager;
@SuppressWarnings("ClassTypeParameterName")
abstract class SmtInterpolNumeralFormulaManager<
ParamFormulaType extends NumeralFormula, ResultFormulaType extends NumeralFormula>
extends AbstractNumeralFormulaManager<
Term, Sort, Script, ParamFormulaType, ResultFormulaType, FunctionSymbol> {
/** Operators for arithmetic functions that return a numeric value. */
private static final ImmutableSet<String> NUMERIC_FUNCTIONS =
ImmutableSet.of("+", "-", "*", "/", "div", "mod");
protected final Script env;
SmtInterpolNumeralFormulaManager(
SmtInterpolFormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
env = pCreator.getEnv();
}
/** check for ConstantTerm with Number or ApplicationTerm with negative Number. */
@Override
protected final boolean isNumeral(Term t) {
boolean is = false;
// ConstantTerm with Number --> "123"
if (t instanceof ConstantTerm) {
Object value = ((ConstantTerm) t).getValue();
if (value instanceof Number || value instanceof Rational) {
is = true;
}
} else if (t instanceof ApplicationTerm) {
ApplicationTerm at = (ApplicationTerm) t;
// ApplicationTerm with negative Number --> "(- 123)"
if ("-".equals(at.getFunction().getName())
&& (at.getParameters().length == 1)
&& isNumeral(at.getParameters()[0])) {
is = true;
// ApplicationTerm with Division --> "(/ 1 5)"
} else if ("/".equals(at.getFunction().getName())
&& (at.getParameters().length == 2)
&& isNumeral(at.getParameters()[0])
&& isNumeral(at.getParameters()[1])) {
is = true;
}
}
// TODO hex or binary data, string?
return is;
}
/**
* Check whether the current term is numeric and the value of a term is determined by only
* numerals, i.e. no variable is contained. This method should check as precisely as possible the
* situations in which SMTInterpol supports arithmetic operations like multiplications.
*
* <p>Example: TRUE for "1", "2+3", "ite(x,2,3) and FALSE for "x", "x+2", "ite(1=2,x,0)"
*/
boolean consistsOfNumerals(Term val) {
Set<Term> finished = new HashSet<>();
Deque<Term> waitlist = new ArrayDeque<>();
waitlist.add(val);
while (!waitlist.isEmpty()) {
Term t = waitlist.pop();
if (!finished.add(t)) {
continue;
}
if (isNumeral(t)) {
// true, skip and check others
} else if (t instanceof ApplicationTerm) {
final ApplicationTerm app = (ApplicationTerm) t;
final FunctionSymbol func = app.getFunction();
final Term[] params = app.getParameters();
if (params.length == 0) {
return false;
} else if (NUMERIC_FUNCTIONS.contains(func.getName())) {
waitlist.addAll(Arrays.asList(params));
} else if ("ite".equals(func.getName())) {
// ignore condition, just use the if- and then-case
waitlist.add(params[1]);
waitlist.add(params[2]);
} else {
return false;
}
} else {
return false;
}
}
return true;
}
@Override
public Term negate(Term pNumber) {
return env.term("*", env.numeral("-1"), pNumber);
}
@Override
public Term add(Term pNumber1, Term pNumber2) {
return env.term("+", pNumber1, pNumber2);
}
@Override
public Term subtract(Term pNumber1, Term pNumber2) {
return env.term("-", pNumber1, pNumber2);
}
@Override
public Term multiply(Term pNumber1, Term pNumber2) {
if (consistsOfNumerals(pNumber1) || consistsOfNumerals(pNumber2)) {
return env.term("*", pNumber1, pNumber2);
} else {
return super.multiply(pNumber1, pNumber2);
}
}
@Override
public Term equal(Term pNumber1, Term pNumber2) {
return env.term("=", pNumber1, pNumber2);
}
@Override
public Term distinctImpl(List<Term> pNumbers) {
return env.term("distinct", pNumbers.toArray(new Term[0]));
}
@Override
public Term greaterThan(Term pNumber1, Term pNumber2) {
return env.term(">", pNumber1, pNumber2);
}
@Override
public Term greaterOrEquals(Term pNumber1, Term pNumber2) {
return env.term(">=", pNumber1, pNumber2);
}
@Override
public Term lessThan(Term pNumber1, Term pNumber2) {
return env.term("<", pNumber1, pNumber2);
}
@Override
public Term lessOrEquals(Term pNumber1, Term pNumber2) {
return env.term("<=", pNumber1, pNumber2);
}
}
| 5,579 | 31.068966 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolRationalFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import de.uni_freiburg.informatik.ultimate.logic.Sort;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import java.math.BigDecimal;
import java.math.BigInteger;
import org.sosy_lab.common.rationals.Rational;
import org.sosy_lab.java_smt.api.NumeralFormula;
import org.sosy_lab.java_smt.api.NumeralFormula.RationalFormula;
import org.sosy_lab.java_smt.api.RationalFormulaManager;
class SmtInterpolRationalFormulaManager
extends SmtInterpolNumeralFormulaManager<NumeralFormula, RationalFormula>
implements RationalFormulaManager {
SmtInterpolRationalFormulaManager(
SmtInterpolFormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
}
@Override
protected Term makeNumberImpl(long i) {
return env.decimal(BigDecimal.valueOf(i));
}
@Override
protected Term makeNumberImpl(BigInteger pI) {
return env.decimal(new BigDecimal(pI));
}
@Override
protected Term makeNumberImpl(String pI) {
return env.decimal(pI);
}
@Override
protected Term makeNumberImpl(Rational pI) {
return env.getTheory()
.rational(
de.uni_freiburg.informatik.ultimate.logic.Rational.valueOf(pI.getNum(), pI.getDen()),
env.getTheory().getRealSort());
}
@Override
protected Term makeNumberImpl(double pNumber) {
return env.decimal(BigDecimal.valueOf(pNumber));
}
@Override
protected Term makeNumberImpl(BigDecimal pNumber) {
return env.decimal(pNumber);
}
@Override
protected Term makeVariableImpl(String varName) {
Sort t = getFormulaCreator().getRationalType();
return getFormulaCreator().makeVariable(t, varName);
}
@Override
public Term divide(Term pNumber1, Term pNumber2) {
if (consistsOfNumerals(pNumber2)) {
Sort intSort = pNumber1.getTheory().getNumericSort();
Sort realSort = pNumber1.getTheory().getRealSort();
assert intSort.equals(pNumber1.getSort()) || realSort.equals(pNumber1.getSort());
assert intSort.equals(pNumber2.getSort()) || realSort.equals(pNumber2.getSort());
return env.term("/", pNumber1, pNumber2);
} else {
return super.divide(pNumber1, pNumber2);
}
}
@Override
protected Term floor(Term pNumber) {
return env.term("to_int", pNumber);
}
}
| 2,584 | 29.05814 | 97 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolSolverContext.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import de.uni_freiburg.informatik.ultimate.logic.LoggingScript;
import de.uni_freiburg.informatik.ultimate.logic.Logics;
import de.uni_freiburg.informatik.ultimate.logic.QuotedObject;
import de.uni_freiburg.informatik.ultimate.logic.SMTLIBException;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.WrapperScript;
import de.uni_freiburg.informatik.ultimate.smtinterpol.option.OptionMap.CopyMode;
import de.uni_freiburg.informatik.ultimate.smtinterpol.smtlib2.SMTInterpol;
import java.io.IOException;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
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.common.log.LogManager;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
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.AbstractNumeralFormulaManager.NonLinearArithmetic;
import org.sosy_lab.java_smt.basicimpl.AbstractSolverContext;
public final class SmtInterpolSolverContext extends AbstractSolverContext {
@Options(prefix = "solver.smtinterpol")
private static class SmtInterpolSettings {
@Option(
secure = true,
description =
"Double check generated results like interpolants and models whether they are correct")
private boolean checkResults = false;
@Option(
secure = true,
description =
"Further options that will be set to true for SMTInterpol "
+ "in addition to the default options. Format is 'option1,option2,option3'")
private List<String> furtherOptions = ImmutableList.of();
private final @Nullable PathCounterTemplate smtLogfile;
private final ImmutableMap<String, Object> optionsMap;
private SmtInterpolSettings(
Configuration config, long pRandomSeed, @Nullable PathCounterTemplate pSmtLogfile)
throws InvalidConfigurationException {
config.inject(this);
smtLogfile = pSmtLogfile;
ImmutableMap.Builder<String, Object> opt = ImmutableMap.builder();
opt.put(":global-declarations", true);
opt.put(":random-seed", pRandomSeed);
// We always need to enable the option for interpolation, even if interpolation is not used.
// Otherwise, using interpolation later does not work.
opt.put(":produce-interpolants", true);
if (checkResults) {
opt.put(":interpolant-check-mode", true);
opt.put(":unsat-core-check-mode", true);
opt.put(":model-check-mode", true);
}
for (String option : furtherOptions) {
opt.put(option, true);
}
optionsMap = opt.buildOrThrow();
}
}
private final SmtInterpolSettings settings;
private final ShutdownNotifier shutdownNotifier;
private final SmtInterpolFormulaManager manager;
private SmtInterpolSolverContext(
SmtInterpolFormulaManager pManager,
ShutdownNotifier pShutdownNotifier,
SmtInterpolSettings pSettings) {
super(pManager);
settings = pSettings;
shutdownNotifier = checkNotNull(pShutdownNotifier);
manager = pManager;
}
public static SmtInterpolSolverContext create(
Configuration config,
LogManager logger,
ShutdownNotifier pShutdownNotifier,
@Nullable PathCounterTemplate smtLogfile,
long randomSeed,
NonLinearArithmetic pNonLinearArithmetic)
throws InvalidConfigurationException {
SmtInterpolSettings settings = new SmtInterpolSettings(config, randomSeed, smtLogfile);
Script script = getSmtInterpolScript(pShutdownNotifier, smtLogfile, settings, logger);
SmtInterpolFormulaCreator creator = new SmtInterpolFormulaCreator(script);
SmtInterpolUFManager functionTheory = new SmtInterpolUFManager(creator);
SmtInterpolBooleanFormulaManager booleanTheory = new SmtInterpolBooleanFormulaManager(creator);
SmtInterpolIntegerFormulaManager integerTheory =
new SmtInterpolIntegerFormulaManager(creator, pNonLinearArithmetic);
SmtInterpolRationalFormulaManager rationalTheory =
new SmtInterpolRationalFormulaManager(creator, pNonLinearArithmetic);
SmtInterpolArrayFormulaManager arrayTheory = new SmtInterpolArrayFormulaManager(creator);
SmtInterpolFormulaManager manager =
new SmtInterpolFormulaManager(
creator,
functionTheory,
booleanTheory,
integerTheory,
rationalTheory,
arrayTheory,
logger);
return new SmtInterpolSolverContext(manager, pShutdownNotifier, settings);
}
/** instantiate the central SMTInterpol script from where all others are copied. */
private static Script getSmtInterpolScript(
ShutdownNotifier pShutdownNotifier,
@javax.annotation.Nullable PathCounterTemplate smtLogfile,
SmtInterpolSettings settings,
LogManager logger)
throws InvalidConfigurationException {
LogProxyForwarder smtInterpolLogProxy =
new LogProxyForwarder(logger.withComponentName("SMTInterpol"));
final SMTInterpol smtInterpol =
new SMTInterpol(smtInterpolLogProxy, pShutdownNotifier::shouldShutdown);
final Script script = wrapInLoggingScriptIfNeeded(smtInterpol, smtLogfile);
for (Map.Entry<String, Object> entry : settings.optionsMap.entrySet()) {
try {
script.setOption(entry.getKey(), entry.getValue());
} catch (SMTLIBException | UnsupportedOperationException e) {
throw new InvalidConfigurationException(
"Invalid option \"" + entry.getKey() + "=" + entry.getValue() + "\" for SMTInterpol.",
e);
}
}
// TODO: We would like to use Logics.ALL here and let the solver decide which logics are needed.
// But ... SMTInterpol eagerly checks logics for model generation,
// so we limit the available theories here to a large set of logics,
// including Arrays, UFs, and non-linear arithmetics over Ints and Rationals.
script.setLogic(Logics.AUFNIRA);
return script;
}
private static Script wrapInLoggingScriptIfNeeded(
SMTInterpol smtInterpol, @Nullable PathCounterTemplate smtLogfileTemplate)
throws InvalidConfigurationException {
if (smtLogfileTemplate == null) {
return smtInterpol;
} else {
Path smtLogfile = smtLogfileTemplate.getFreshPath();
String filename = smtLogfile.toAbsolutePath().toString();
try {
// create a thin wrapper around Benchmark,
// this allows to write most formulas of the solver to outputfile
return new LoggingScript(smtInterpol, filename, true, true);
} catch (IOException e) {
throw new InvalidConfigurationException(
"Could not open log file for SMTInterpol queries.", e);
}
}
}
/**
* use the copy-constructor of SMTInterpol and create a new script. The new script has its own
* assertion stack, but shares all symbols.
*/
private Script createNewScript(Set<ProverOptions> pOptions) {
Map<String, Object> newOptions = new LinkedHashMap<>(settings.optionsMap);
// We need to enable interpolation support globally. See above.
// newOptions.put(":produce-interpolants", enableInterpolation);
newOptions.put(
":produce-unsat-cores",
pOptions.contains(ProverOptions.GENERATE_UNSAT_CORE)
|| pOptions.contains(ProverOptions.GENERATE_UNSAT_CORE_OVER_ASSUMPTIONS));
newOptions.put(":produce-models", pOptions.contains(ProverOptions.GENERATE_MODELS));
SMTInterpol smtInterpol =
new SMTInterpol(getSmtInterpol(), newOptions, CopyMode.RESET_TO_DEFAULT);
try {
return wrapInLoggingScriptIfNeeded(smtInterpol, settings.smtLogfile);
} catch (InvalidConfigurationException e) {
throw new IllegalStateException(e);
}
}
/** extract the central SMTInterpol instance. */
private SMTInterpol getSmtInterpol() {
final Script script = manager.getEnvironment();
if (script instanceof SMTInterpol) {
return (SMTInterpol) script;
} else if (script instanceof WrapperScript) {
return checkNotNull((WrapperScript) script).findBacking(SMTInterpol.class);
} else {
throw new AssertionError("unexpected class for SMTInterpol: " + script.getClass());
}
}
@SuppressWarnings("resource")
@Override
protected ProverEnvironment newProverEnvironment0(Set<ProverOptions> options) {
Script newScript = createNewScript(options);
return new SmtInterpolTheoremProver(manager, newScript, options, shutdownNotifier);
}
@SuppressWarnings("resource")
@Override
protected InterpolatingProverEnvironment<?> newProverEnvironmentWithInterpolation0(
Set<ProverOptions> options) {
Script newScript = createNewScript(options);
final SmtInterpolInterpolatingProver prover;
if (settings.smtLogfile == null) {
prover = new SmtInterpolInterpolatingProver(manager, newScript, options, shutdownNotifier);
} else {
prover =
new LoggingSmtInterpolInterpolatingProver(
manager,
newScript,
options,
shutdownNotifier,
settings.optionsMap,
settings.smtLogfile.getFreshPath());
}
return prover;
}
@Override
public OptimizationProverEnvironment newOptimizationProverEnvironment0(
Set<ProverOptions> options) {
throw new UnsupportedOperationException("SMTInterpol does not support optimization");
}
@Override
public String getVersion() {
QuotedObject program = (QuotedObject) manager.getEnvironment().getInfo(":name");
QuotedObject version = (QuotedObject) manager.getEnvironment().getInfo(":version");
return program.getValue() + " " + version.getValue();
}
@Override
public Solvers getSolverName() {
return Solvers.SMTINTERPOL;
}
@Override // TODO remove?
public ImmutableMap<String, String> getStatistics() {
ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
flatten(builder, "", manager.getEnvironment().getInfo(":all-statistics"));
return builder.buildOrThrow();
}
/**
* This method returns a flattened mapping converted from a nested array-based structure, in which
* each entry is a key-value-pair. The key of such a key-value-pair is a String, the value can be
* a numeric value or a String.
*
* <p>We assume only a small nesting level and only a few keys, otherwise we must improve
* performance of this method.
*
* <p>Example:
* <li>input: {[a, {[b, 1], [c, 2]}], [d, 3], [e, {[f, 4]}]}
* <li>output: {ab:1, ac:2, d:3, ef:4}
*/
static void flatten(ImmutableMap.Builder<String, String> builder, String prefix, Object obj) {
if (obj instanceof Object[]) { // very type-safe structure! :-(
if (!prefix.isEmpty()) {
prefix += ">"; // separator for next nesting level
}
for (Object entry : (Object[]) obj) {
checkArgument(
entry instanceof Object[],
"expected key-value-pair, but found an unexpected structure: %s",
obj);
Object[] keyValue = (Object[]) entry;
checkArgument(
keyValue.length == 2,
"expected key-value-pair, but found an unexpected structure: %s",
lazyDeepToString(keyValue));
flatten(builder, prefix + keyValue[0], keyValue[1]);
}
} else {
builder.put(prefix, obj.toString());
}
}
private static Object lazyDeepToString(Object[] value) {
return new Object() {
@Override
public String toString() {
return Arrays.deepToString(value);
}
};
}
@Override
public void close() {}
@Override
protected boolean supportsAssumptionSolving() {
return false;
}
}
| 12,779 | 37.610272 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolTheoremProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import com.google.common.base.Preconditions;
import de.uni_freiburg.informatik.ultimate.logic.Annotation;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
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.ProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
class SmtInterpolTheoremProver extends SmtInterpolAbstractProver<Void, Term>
implements ProverEnvironment {
SmtInterpolTheoremProver(
SmtInterpolFormulaManager pMgr,
Script pEnv,
Set<ProverOptions> options,
ShutdownNotifier pShutdownNotifier) {
super(pMgr, pEnv, options, pShutdownNotifier);
}
@Override
@Nullable
public Void addConstraint(BooleanFormula constraint) {
Preconditions.checkState(!closed);
Term t = mgr.extractInfo(constraint);
if (generateUnsatCores) {
String termName = generateTermName();
Term annotated = env.annotate(t, new Annotation(":named", termName));
annotatedTerms.put(termName, t);
env.assertTerm(annotated);
} else {
env.assertTerm(t);
}
assertedFormulas.peek().add(t);
return null;
}
@Override
protected Collection<Term> getAssertedTerms() {
List<Term> result = new ArrayList<>();
assertedFormulas.forEach(result::addAll);
return result;
}
}
| 1,875 | 30.266667 | 76 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolUFManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import de.uni_freiburg.informatik.ultimate.logic.FunctionSymbol;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Sort;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import org.sosy_lab.java_smt.basicimpl.AbstractUFManager;
class SmtInterpolUFManager extends AbstractUFManager<Term, FunctionSymbol, Sort, Script> {
SmtInterpolUFManager(SmtInterpolFormulaCreator creator) {
super(creator);
}
}
| 761 | 32.130435 | 90 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/SmtInterpolUtil.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.smtinterpol;
import de.uni_freiburg.informatik.ultimate.logic.ApplicationTerm;
import de.uni_freiburg.informatik.ultimate.logic.Term;
/** Collection of utilities for working with SmtInterpol. */
final class SmtInterpolUtil {
private SmtInterpolUtil() {}
/** this function can be used to print a bigger term. */
public static String prettyPrint(Term t) {
StringBuilder str = new StringBuilder();
prettyPrint(t, str, 0);
return str.toString();
}
private static void prettyPrint(Term t, StringBuilder str, int n) {
str.append(" ".repeat(n));
if (t instanceof ApplicationTerm) {
ApplicationTerm at = (ApplicationTerm) t;
String function = at.getFunction().getName();
if ("and".equals(function) || "or".equals(function)) {
str.append('(').append(function).append('\n');
for (Term child : at.getParameters()) {
prettyPrint(child, str, n + 1);
}
str.append(" ".repeat(n));
str.append(")\n");
} else {
str.append(t.toStringDirect()).append('\n');
}
} else {
str.append(t.toStringDirect()).append('\n');
}
}
}
| 1,419 | 30.555556 | 69 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/smtinterpol/package-info.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
/** Interface to the SMT solver SMTInterpol. */
@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.smtinterpol;
| 563 | 36.6 | 69 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2BitvectorFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvadd;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvand2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvashr;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvconcat2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvdiv;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bveq_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvextract;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvge_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvgt_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvle_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvlshr;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvlt_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvmul;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvneg;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvnot;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvor2;
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_bvsgt_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvshl;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvsle_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvslt_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvsrem;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvsub;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvxor2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_parse_bvbin;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_sign_extend;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_zero_extend;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import java.math.BigInteger;
import org.sosy_lab.java_smt.basicimpl.AbstractBitvectorFormulaManager;
public class Yices2BitvectorFormulaManager
extends AbstractBitvectorFormulaManager<Integer, Integer, Long, Integer> {
protected Yices2BitvectorFormulaManager(
Yices2FormulaCreator pCreator, Yices2BooleanFormulaManager pBmgr) {
super(pCreator, pBmgr);
}
@Override
protected Integer makeBitvectorImpl(int pLength, BigInteger pI) {
pI = transformValueToRange(pLength, pI);
String bits = pI.toString(2);
assert bits.length() <= pLength
: "numeral value " + pI + " is out of range for size " + pLength;
if (bits.length() < pLength) {
bits = Strings.padStart(bits, pLength, '0');
}
Preconditions.checkArgument(bits.length() == pLength, "Bitvector has unexpected size.");
return yices_parse_bvbin(bits);
}
@Override
protected Integer toIntegerFormulaImpl(Integer bvFormula, boolean pSigned) {
throw new UnsupportedOperationException(
"Yices does not support making an INT formula from a BV formula as of Version 2.6.1. "
+ "Support is planned for a future release.");
}
@Override
protected Integer negate(Integer pParam1) {
return yices_bvneg(pParam1);
}
@Override
protected Integer add(Integer pParam1, Integer pParam2) {
return yices_bvadd(pParam1, pParam2);
}
@Override
protected Integer subtract(Integer pParam1, Integer pParam2) {
return yices_bvsub(pParam1, pParam2);
}
@Override
protected Integer divide(Integer pParam1, Integer pParam2, boolean pSigned) {
if (pSigned) {
return yices_bvsdiv(pParam1, pParam2);
} else {
return yices_bvdiv(pParam1, pParam2);
}
}
@Override
protected Integer modulo(Integer pParam1, Integer pParam2, boolean pSigned) {
// TODO Correct Methods?
if (pSigned) {
return yices_bvsrem(pParam1, pParam2);
} else {
return yices_bvrem(pParam1, pParam2);
}
}
@Override
protected Integer multiply(Integer pParam1, Integer pParam2) {
return yices_bvmul(pParam1, pParam2);
}
@Override
protected Integer equal(Integer pParam1, Integer pParam2) {
return yices_bveq_atom(pParam1, pParam2);
}
@Override
protected Integer greaterThan(Integer pParam1, Integer pParam2, boolean pSigned) {
if (pSigned) {
return yices_bvsgt_atom(pParam1, pParam2);
} else {
return yices_bvgt_atom(pParam1, pParam2);
}
}
@Override
protected Integer greaterOrEquals(Integer pParam1, Integer pParam2, boolean pSigned) {
if (pSigned) {
return yices_bvsge_atom(pParam1, pParam2);
} else {
return yices_bvge_atom(pParam1, pParam2);
}
}
@Override
protected Integer lessThan(Integer pParam1, Integer pParam2, boolean pSigned) {
if (pSigned) {
return yices_bvslt_atom(pParam1, pParam2);
} else {
return yices_bvlt_atom(pParam1, pParam2);
}
}
@Override
protected Integer lessOrEquals(Integer pParam1, Integer pParam2, boolean pSigned) {
if (pSigned) {
return yices_bvsle_atom(pParam1, pParam2);
} else {
return yices_bvle_atom(pParam1, pParam2);
}
}
@Override
protected Integer not(Integer pParam1) {
return yices_bvnot(pParam1);
}
@Override
protected Integer and(Integer pParam1, Integer pParam2) {
return yices_bvand2(pParam1, pParam2);
}
@Override
protected Integer or(Integer pParam1, Integer pParam2) {
return yices_bvor2(pParam1, pParam2);
}
@Override
protected Integer xor(Integer pParam1, Integer pParam2) {
return yices_bvxor2(pParam1, pParam2);
}
@Override
protected Integer makeVariableImpl(int pLength, String pVar) {
int bvType = getFormulaCreator().getBitvectorType(pLength);
return getFormulaCreator().makeVariable(bvType, pVar);
}
@Override
protected Integer shiftRight(Integer pNumber, Integer pToShift, boolean pSigned) {
if (pSigned) {
return yices_bvashr(pNumber, pToShift);
} else {
return yices_bvlshr(pNumber, pToShift);
}
}
@Override
protected Integer shiftLeft(Integer pNumber, Integer pToShift) {
return yices_bvshl(pNumber, pToShift);
}
@Override
protected Integer concat(Integer pNumber, Integer pAppend) {
return yices_bvconcat2(pNumber, pAppend);
}
@Override
protected Integer extract(Integer pNumber, int pMsb, int pLsb) {
return yices_bvextract(pNumber, pLsb, pMsb);
}
@Override
protected Integer extend(Integer pNumber, int pExtensionBits, boolean pSigned) {
if (pSigned) {
return yices_sign_extend(pNumber, pExtensionBits);
} else {
return yices_zero_extend(pNumber, pExtensionBits);
}
}
@Override
protected Integer makeBitvectorImpl(int pLength, Integer pFormula) {
throw new UnsupportedOperationException(
"Yices does not support making a BV formula from an INT formula as of Version 2.6.1. "
+ "Support is planned for a future release.");
}
}
| 7,778 | 34.359091 | 94 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2BooleanFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_and2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_false;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_iff;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_implies;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_ite;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_not;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_or2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_true;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_xor2;
import org.sosy_lab.java_smt.basicimpl.AbstractBooleanFormulaManager;
public class Yices2BooleanFormulaManager
extends AbstractBooleanFormulaManager<Integer, Integer, Long, Integer> {
protected Yices2BooleanFormulaManager(Yices2FormulaCreator pCreator) {
super(pCreator);
}
@Override
protected Integer makeVariableImpl(String pVar) {
int boolType = getFormulaCreator().getBoolType();
return getFormulaCreator().makeVariable(boolType, pVar);
}
@Override
protected Integer makeBooleanImpl(boolean pValue) {
if (pValue) {
return yices_true();
} else {
return yices_false();
}
}
@Override
protected Integer not(Integer pParam1) {
return yices_not(pParam1);
}
@Override
protected Integer and(Integer pParam1, Integer pParam2) {
return yices_and2(pParam1, pParam2);
}
// Causes BooleanFormulaManagerTest/testConjunctionCollector to fail.
// @Override
// protected Integer andImpl(Collection<Integer> pParams) {
// return yices_and(pParams.size(), Ints.toArray(pParams));
// }
@Override
protected Integer or(Integer pParam1, Integer pParam2) {
return yices_or2(pParam1, pParam2);
}
// Causes BooleanFormulaManagerTest/testDisjunctionCollector to fail.
// @Override
// protected Integer orImpl(Collection<Integer> pParams) {
// return yices_or(pParams.size(), Ints.toArray(pParams));
// }
@Override
protected Integer xor(Integer pParam1, Integer pParam2) {
return yices_xor2(pParam1, pParam2);
}
@Override
protected Integer equivalence(Integer pBits1, Integer pBits2) {
return yices_iff(pBits1, pBits2);
}
@Override
protected Integer implication(Integer bits1, Integer bits2) {
return yices_implies(bits1, bits2);
}
@Override
protected boolean isTrue(Integer pBits) {
return pBits.equals(yices_true());
}
@Override
protected boolean isFalse(Integer pBits) {
return pBits.equals(yices_false());
}
@Override
protected Integer ifThenElse(Integer pCond, Integer pF1, Integer pF2) {
return yices_ite(pCond, pF1, pF2);
}
}
| 3,109 | 29.490196 | 81 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2Formula.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_term_to_string;
import com.google.errorprone.annotations.Immutable;
import org.sosy_lab.java_smt.api.BitvectorFormula;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.NumeralFormula.RationalFormula;
@Immutable
abstract class Yices2Formula implements Formula {
private final int yicesTerm;
Yices2Formula(int term) {
this.yicesTerm = term;
}
@Override
public final int hashCode() {
return yicesTerm;
}
final int getTerm() {
return yicesTerm;
}
@Override
public final String toString() {
return yices_term_to_string(yicesTerm);
}
@Override
public final boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof Yices2Formula)) {
return false;
}
return yicesTerm == ((Yices2Formula) o).yicesTerm;
}
@Immutable
static final class Yices2BitvectorFormula extends Yices2Formula implements BitvectorFormula {
Yices2BitvectorFormula(int pTerm) {
super(pTerm);
}
}
@Immutable
static final class Yices2IntegerFormula extends Yices2Formula implements IntegerFormula {
Yices2IntegerFormula(int pTerm) {
super(pTerm);
}
}
@Immutable
static final class Yices2RationalFormula extends Yices2Formula implements RationalFormula {
Yices2RationalFormula(int pTerm) {
super(pTerm);
}
}
@Immutable
static final class Yices2BooleanFormula extends Yices2Formula implements BooleanFormula {
Yices2BooleanFormula(int pTerm) {
super(pTerm);
}
}
}
| 2,026 | 23.719512 | 95 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2FormulaCreator.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
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 com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import com.google.common.primitives.Ints;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.sosy_lab.common.rationals.Rational;
import org.sosy_lab.java_smt.api.BitvectorFormula;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.FormulaType.FloatingPointType;
import org.sosy_lab.java_smt.api.FunctionDeclarationKind;
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.yices2.Yices2Formula.Yices2BitvectorFormula;
import org.sosy_lab.java_smt.solvers.yices2.Yices2Formula.Yices2BooleanFormula;
import org.sosy_lab.java_smt.solvers.yices2.Yices2Formula.Yices2IntegerFormula;
import org.sosy_lab.java_smt.solvers.yices2.Yices2Formula.Yices2RationalFormula;
public class Yices2FormulaCreator extends FormulaCreator<Integer, Integer, Long, Integer> {
private static final ImmutableSet<Integer> CONSTANT_AND_VARIABLE_CONSTRUCTORS =
ImmutableSet.of(
YICES_BOOL_CONST,
YICES_ARITH_CONST,
YICES_BV_CONST,
YICES_VARIABLE,
YICES_UNINTERPRETED_TERM);
protected Yices2FormulaCreator() {
super(null, yices_bool_type(), yices_int_type(), yices_real_type(), null, null);
}
@Override
public Integer getBitvectorType(int pBitwidth) {
return yices_bv_type(pBitwidth);
}
@Override
public Integer getFloatingPointType(FloatingPointType pType) {
throw new UnsupportedOperationException();
}
@Override
public Integer getArrayType(Integer pIndexType, Integer pElementType) {
throw new UnsupportedOperationException();
}
@Override
public Integer makeVariable(Integer pType, String pVarName) {
return yices_named_variable(pType, pVarName);
}
@Override
public Integer extractInfo(Formula pT) {
return Yices2FormulaManager.getYicesTerm(pT);
}
@SuppressWarnings("unchecked")
@Override
public <T extends Formula> T encapsulate(FormulaType<T> pType, Integer pTerm) {
// INTEGER is basic type and also used for function applications like EXTRACT/EXPAND.
// RATIONAL can be used to model INTEGERS. Otherwise, the type should match exactly.
assert FormulaType.IntegerType.equals(pType)
|| (FormulaType.RationalType.equals(pType)
&& FormulaType.IntegerType.equals(getFormulaType(pTerm)))
|| pType.equals(getFormulaType(pTerm))
: String.format(
"Trying to encapsulate formula %s of type %s as %s",
yices_term_to_string(pTerm), getFormulaType(pTerm), pType);
if (pType.isBooleanType()) {
return (T) new Yices2BooleanFormula(pTerm);
} else if (pType.isIntegerType()) {
return (T) new Yices2IntegerFormula(pTerm);
} else if (pType.isRationalType()) {
return (T) new Yices2RationalFormula(pTerm);
} else if (pType.isBitvectorType()) {
return (T) new Yices2BitvectorFormula(pTerm);
}
throw new IllegalArgumentException("Cannot create formulas of type " + pType + " in Yices");
}
@Override
public BooleanFormula encapsulateBoolean(Integer pTerm) {
assert getFormulaType(pTerm).isBooleanType();
return new Yices2BooleanFormula(pTerm);
}
@Override
public BitvectorFormula encapsulateBitvector(Integer pTerm) {
assert getFormulaType(pTerm).isBitvectorType();
return new Yices2BitvectorFormula(pTerm);
}
@SuppressWarnings("unchecked")
@Override
public <T extends Formula> FormulaType<T> getFormulaType(T pFormula) {
if (pFormula instanceof BitvectorFormula) {
int type = yices_type_of_term(extractInfo(pFormula));
return (FormulaType<T>) FormulaType.getBitvectorTypeWithSize(yices_bvtype_size(type));
} else {
return super.getFormulaType(pFormula);
}
}
@Override
public FormulaType<?> getFormulaType(Integer pFormula) {
if (yices_term_is_bool(pFormula)) {
return FormulaType.BooleanType;
} else if (yices_term_is_int(pFormula)) {
return FormulaType.IntegerType;
} else if (yices_term_is_real(pFormula)) {
return FormulaType.RationalType;
} else if (yices_term_is_bitvector(pFormula)) {
return FormulaType.getBitvectorTypeWithSize(yices_term_bitsize(pFormula));
}
throw new IllegalArgumentException(
String.format(
"Unknown formula type '%s' for formula '%s'",
yices_type_to_string(yices_type_of_term(pFormula)), yices_term_to_string(pFormula)));
}
@Override
public <R> R visit(FormulaVisitor<R> pVisitor, Formula pFormula, Integer pF) {
int constructor = yices_term_constructor(pF);
switch (constructor) {
case YICES_BOOL_CONST:
return pVisitor.visitConstant(pFormula, yices_bool_const_value(pF));
case YICES_ARITH_CONST:
return pVisitor.visitConstant(pFormula, convertValue(pF, pF));
case YICES_BV_CONST:
return pVisitor.visitConstant(pFormula, convertValue(pF, pF));
case YICES_UNINTERPRETED_TERM:
return pVisitor.visitFreeVariable(pFormula, yices_get_term_name(pF));
default:
return visitFunctionApplication(pVisitor, pFormula, pF, constructor);
}
}
private <R> R visitFunctionApplication(
FormulaVisitor<R> pVisitor, Formula pFormula, int pF, final int constructor) {
// Map built-in constructors in negative int to avoid collision with UFs.
int functionDeclaration = -constructor;
assert !CONSTANT_AND_VARIABLE_CONSTRUCTORS.contains(constructor)
: String.format(
"Term %s with constructor %d should be handled somewhere else",
yices_term_to_string(pF), constructor);
// filled later, except for some special function applications
String functionName = null;
List<Integer> functionArgs = null;
// filled directly when handling the function application
final FunctionDeclarationKind functionKind;
switch (constructor) {
case YICES_ITE_TERM:
functionKind = FunctionDeclarationKind.ITE;
break;
case YICES_APP_TERM:
functionKind = FunctionDeclarationKind.UF;
functionArgs = getArgs(pF);
functionName = yices_term_to_string(functionArgs.get(0));
functionDeclaration = functionArgs.get(0);
functionArgs.remove(0);
break;
case YICES_EQ_TERM:
functionKind = FunctionDeclarationKind.EQ; // Covers all equivalences
break;
case YICES_NOT_TERM:
if (isNestedConjunction(pF)) {
functionKind = FunctionDeclarationKind.AND;
functionArgs = getNestedConjunctionArgs(pF);
functionDeclaration = -YICES_AND;
} else {
functionKind = FunctionDeclarationKind.NOT;
}
break;
case YICES_OR_TERM:
functionKind = FunctionDeclarationKind.OR;
break;
case YICES_XOR_TERM:
functionKind = FunctionDeclarationKind.XOR;
break;
case YICES_BV_DIV:
functionKind = FunctionDeclarationKind.BV_UDIV;
break;
case YICES_BV_REM:
functionKind = FunctionDeclarationKind.BV_UREM;
break;
case YICES_BV_SDIV:
functionKind = FunctionDeclarationKind.BV_SDIV;
break;
case YICES_BV_SREM:
functionKind = FunctionDeclarationKind.BV_SREM;
break;
case YICES_BV_SHL:
functionKind = FunctionDeclarationKind.BV_SHL;
break;
case YICES_BV_LSHR:
functionKind = FunctionDeclarationKind.BV_LSHR;
break;
case YICES_BV_ASHR:
functionKind = FunctionDeclarationKind.BV_ASHR;
break;
case YICES_BV_GE_ATOM:
functionKind = FunctionDeclarationKind.BV_UGE;
break;
case YICES_BV_SGE_ATOM:
functionKind = FunctionDeclarationKind.BV_SGE;
break;
case YICES_ARITH_GE_ATOM:
functionKind = FunctionDeclarationKind.GTE;
break;
case YICES_FLOOR:
functionKind = FunctionDeclarationKind.FLOOR;
break;
case YICES_RDIV:
functionKind = FunctionDeclarationKind.DIV;
break;
case YICES_IDIV:
functionKind = FunctionDeclarationKind.DIV;
break;
case YICES_SELECT_TERM:
functionKind = FunctionDeclarationKind.SELECT;
break;
case YICES_BV_SUM:
if (yices_term_num_children(pF) == 1) {
functionKind = FunctionDeclarationKind.BV_MUL;
functionArgs = getMultiplyBvSumArgsFromSum(pF);
functionDeclaration = -YICES_BV_MUL;
} else {
functionKind = FunctionDeclarationKind.BV_ADD;
functionArgs = getBvSumArgs(pF);
}
break;
case YICES_ARITH_SUM:
if (yices_term_num_children(pF) == 1) {
functionKind = FunctionDeclarationKind.MUL;
functionArgs = getMultiplySumArgsFromSum(pF);
functionDeclaration = -YICES_POWER_PRODUCT;
} else {
functionKind = FunctionDeclarationKind.ADD;
functionArgs = getSumArgs(pF);
}
break;
case YICES_POWER_PRODUCT:
if (yices_type_is_bitvector(yices_type_of_term(pF))) {
functionKind = FunctionDeclarationKind.BV_MUL;
functionArgs = getMultiplyArgs(pF, true);
functionDeclaration = -YICES_BV_MUL;
// TODO Product of more then 2 bitvectors ?
} else {
functionKind = FunctionDeclarationKind.MUL;
functionArgs = getMultiplyArgs(pF, false);
}
break;
case YICES_BIT_TERM:
functionKind = FunctionDeclarationKind.BV_EXTRACT;
functionArgs = getBitArgs(pF);
break;
case YICES_BV_ARRAY:
functionKind = FunctionDeclarationKind.BV_CONCAT;
break;
default:
functionKind = FunctionDeclarationKind.OTHER;
}
if (functionName == null) {
functionName = functionKind.toString();
}
if (functionArgs == null) {
functionArgs = getArgs(pF);
}
final ImmutableList<FormulaType<?>> argTypes = ImmutableList.copyOf(toType(functionArgs));
Preconditions.checkState(
functionArgs.size() == argTypes.size(),
"different size of args (%s) and their types (%s) in term %s",
functionArgs,
argTypes,
pFormula);
final ImmutableList.Builder<Formula> argsBuilder = ImmutableList.builder();
for (int i = 0; i < functionArgs.size(); i++) {
argsBuilder.add(encapsulate(argTypes.get(i), functionArgs.get(i)));
}
final ImmutableList<Formula> args = argsBuilder.build();
return pVisitor.visitFunction(
pFormula,
args,
FunctionDeclarationImpl.of(
functionName, functionKind, argTypes, getFormulaType(pF), functionDeclaration));
}
private List<FormulaType<?>> toType(final List<Integer> args) {
return Lists.transform(args, this::getFormulaType);
}
/** Yices transforms <code>AND(x,...)</code> into <code>NOT(OR(NOT(X),NOT(...))</code>. */
private static boolean isNestedConjunction(int outerTerm) {
if (yices_term_constructor(outerTerm) != YICES_NOT_TERM) {
return false;
}
int middleTerm = yices_term_child(outerTerm, 0);
if (yices_term_constructor(middleTerm) != YICES_OR_TERM) {
return false;
}
// code commented out --> ignore nested NOTs and just negate all resulting child-terms.
// for (int child : getArgs(middleTerm)) {
// if (yices_term_constructor(child) != YICES_NOT_TERM) {
// return false;
// }
// }
return true;
}
/**
* Yices transforms <code>AND(x,...)</code> into <code>NOT(OR(NOT(X),NOT(...))</code>.
*
* <p>Only call this method for terms that are nested conjunctions!
*/
private static List<Integer> getNestedConjunctionArgs(int outerTerm) {
Preconditions.checkArgument(yices_term_constructor(outerTerm) == YICES_NOT_TERM);
int middleTerm = yices_term_child(outerTerm, 0);
Preconditions.checkArgument(yices_term_constructor(middleTerm) == YICES_OR_TERM);
List<Integer> result = new ArrayList<>();
for (int child : getArgs(middleTerm)) {
result.add(yices_not(child));
}
return result;
}
private static List<Integer> getArgs(int parent) {
try {
return getArgs0(parent);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("problematic term: " + yices_term_to_string(parent), e);
}
}
private static List<Integer> getArgs0(int parent) {
List<Integer> children = new ArrayList<>();
for (int i = 0; i < yices_term_num_children(parent); i++) {
children.add(yices_term_child(parent, i));
}
return children;
}
private static List<Integer> getSumArgs(int parent) {
List<Integer> children = new ArrayList<>();
for (int i = 0; i < yices_term_num_children(parent); i++) {
String[] child = yices_sum_component(parent, i);
String coeff = child[0];
int term = Integer.parseInt(child[1]);
if (term == -1) { // No term just a number
children.add(yices_parse_rational(coeff));
} else {
int coeffTerm = yices_parse_rational(coeff);
children.add(yices_mul(coeffTerm, term));
}
}
return children;
}
/** extract all entries of a BV sum like "3*x + 2*y + 1". */
private static List<Integer> getBvSumArgs(int parent) {
List<Integer> children = new ArrayList<>();
int bitsize = yices_term_bitsize(parent);
for (int i = 0; i < yices_term_num_children(parent); i++) {
int[] component = yices_bvsum_component(parent, i, bitsize);
assert component.length == bitsize + 1;
// the components consist of coefficient (as bits) and variable (if missing: -1)
int coeff = yices_bvconst_from_array(bitsize, Arrays.copyOfRange(component, 0, bitsize));
int term = component[component.length - 1];
if (term == -1) { // No term
children.add(coeff);
} else {
children.add(yices_bvmul(coeff, term));
}
}
return children;
}
/** extract -1 and X from the sum of one element [-1*x]. */
private static List<Integer> getMultiplyBvSumArgsFromSum(int parent) {
Preconditions.checkArgument(yices_term_num_children(parent) == 1);
int bitsize = yices_term_bitsize(parent);
int[] component = yices_bvsum_component(parent, 0, bitsize);
int coeff = yices_bvconst_from_array(bitsize, Arrays.copyOfRange(component, 0, bitsize));
int term = component[component.length - 1];
Preconditions.checkArgument(term != -1, "unexpected constant coeff without variable");
return ImmutableList.of(coeff, term);
}
/** extract -1 and X from the sum of one element [-1*x]. */
private static List<Integer> getMultiplySumArgsFromSum(int parent) {
Preconditions.checkArgument(yices_term_num_children(parent) == 1);
String[] child = yices_sum_component(parent, 0);
int term = Integer.parseInt(child[1]);
Preconditions.checkArgument(term != -1, "unexpected constant coeff without variable");
int coeffTerm = yices_parse_rational(child[0]);
return ImmutableList.of(coeffTerm, term);
}
private static List<Integer> getMultiplyArgs(int parent, boolean isBV) {
// TODO Add exponent?
List<Integer> result = new ArrayList<>();
for (int i = 0; i < yices_term_num_children(parent); i++) {
int[] component = yices_product_component(parent, i);
if (isBV) {
result.add(yices_bvpower(component[0], component[1]));
} else {
result.add(yices_power(component[0], component[1])); // add term, ignore exponent
}
}
return result;
}
/** get "index" and "b" from "(bit index b)". */
private static List<Integer> getBitArgs(int parent) {
return ImmutableList.of(yices_proj_arg(parent), yices_int32(yices_proj_index(parent)));
}
@Override
public Integer callFunctionImpl(Integer pDeclaration, List<Integer> pArgs) {
if (pDeclaration < 0) { // is constant function application from API
switch (-pDeclaration) {
case YICES_ITE_TERM:
checkArgsLength("YICES_ITE_TERM", pArgs, 3);
return yices_ite(pArgs.get(0), pArgs.get(1), pArgs.get(2));
case YICES_EQ_TERM:
checkArgsLength("YICES_EQ_TERM", pArgs, 2);
return yices_eq(pArgs.get(0), pArgs.get(1));
case YICES_DISTINCT_TERM:
return yices_distinct(pArgs.size(), Ints.toArray(pArgs));
case YICES_NOT_TERM:
checkArgsLength("YICES_NOT_TERM", pArgs, 1);
return yices_not(pArgs.get(0));
case YICES_OR_TERM:
return yices_or(pArgs.size(), Ints.toArray(pArgs));
case YICES_XOR_TERM:
return yices_xor(pArgs.size(), Ints.toArray(pArgs));
case YICES_BV_DIV:
checkArgsLength("YICES_BV_DIV", pArgs, 2);
return yices_bvdiv(pArgs.get(0), pArgs.get(1));
case YICES_BV_REM:
checkArgsLength("YICES_BV_REM", pArgs, 2);
return yices_bvrem(pArgs.get(0), pArgs.get(1));
case YICES_BV_SDIV:
checkArgsLength("YICES_BV_SDIV", pArgs, 2);
return yices_bvsdiv(pArgs.get(0), pArgs.get(1));
case YICES_BV_SREM:
checkArgsLength("YICES_BV_SREM", pArgs, 2);
return yices_bvsrem(pArgs.get(0), pArgs.get(1));
case YICES_BV_SMOD:
checkArgsLength("YICES_BV_SMOD", pArgs, 2);
return yices_bvsmod(pArgs.get(0), pArgs.get(1));
case YICES_BV_SHL:
checkArgsLength("YICES_BV_SHL", pArgs, 2);
return yices_bvshl(pArgs.get(0), pArgs.get(1));
case YICES_BV_LSHR:
checkArgsLength("YICES_BV_LSHR", pArgs, 2);
return yices_bvlshr(pArgs.get(0), pArgs.get(1));
case YICES_BV_ASHR:
checkArgsLength("YICES_BV_ASHR", pArgs, 2);
return yices_bvashr(pArgs.get(0), pArgs.get(1));
case YICES_BV_GE_ATOM:
checkArgsLength("YICES_BV_GE_ATOM", pArgs, 2);
return yices_bvge_atom(pArgs.get(0), pArgs.get(1));
case YICES_BV_SGE_ATOM:
checkArgsLength("YICES_BV_SGE_ATOM", pArgs, 2);
return yices_bvsge_atom(pArgs.get(0), pArgs.get(1));
case YICES_ARITH_GE_ATOM:
checkArgsLength("YICES_ARITH_GE_ATOM", pArgs, 2);
return yices_arith_geq_atom(pArgs.get(0), pArgs.get(1));
case YICES_ABS:
checkArgsLength("YICES_ABS", pArgs, 1);
return yices_abs(pArgs.get(0));
case YICES_CEIL:
checkArgsLength("YICES_CEIL", pArgs, 1);
return yices_ceil(pArgs.get(0));
case YICES_FLOOR:
checkArgsLength("YICES_FLOOR", pArgs, 1);
return yices_floor(pArgs.get(0));
case YICES_RDIV:
checkArgsLength("YICES_RDIV", pArgs, 2);
return yices_division(pArgs.get(0), pArgs.get(1));
case YICES_IDIV:
checkArgsLength("YICES_IDIV", pArgs, 2);
return yices_idiv(pArgs.get(0), pArgs.get(1));
case YICES_IMOD:
checkArgsLength("YICES_IMOD", pArgs, 2);
return yices_imod(pArgs.get(0), pArgs.get(1));
case YICES_IS_INT_ATOM:
checkArgsLength("YICES_IS_INT_ATOM", pArgs, 1);
return yices_is_int_atom(pArgs.get(0));
case YICES_DIVIDES_ATOM:
checkArgsLength("YICES_DIVIDES_ATOM", pArgs, 2);
return yices_divides_atom(pArgs.get(0), pArgs.get(1));
case YICES_BV_SUM:
return yices_bvsum(pArgs.size(), Ints.toArray(pArgs));
case YICES_ARITH_SUM:
return yices_sum(pArgs.size(), Ints.toArray(pArgs));
case YICES_POWER_PRODUCT:
return yices_product(pArgs.size(), Ints.toArray(pArgs));
case YICES_BIT_TERM:
checkArgsLength("YICES_BIT_TERM", pArgs, 2);
return yices_bitextract(pArgs.get(0), toInt(pArgs.get(1)));
case YICES_BV_ARRAY:
return yices_bvarray(pArgs.size(), Ints.toArray(pArgs));
case YICES_BV_MUL:
return yices_bvproduct(pArgs.size(), Ints.toArray(pArgs));
case YICES_AND:
return yices_and(pArgs.size(), Ints.toArray(pArgs));
default:
// TODO add more cases
// if something bad happens here,
// in most cases the solution is a fix in the method visitFunctionApplication
throw new IllegalArgumentException(
String.format(
"Unknown function declaration with constructor %d and arguments %s (%s)",
-pDeclaration,
pArgs,
Lists.transform(pArgs, Yices2NativeApi::yices_term_to_string)));
}
} else { // is UF Application
if (pArgs.isEmpty()) {
return pDeclaration;
} else {
int[] argArray = Ints.toArray(pArgs);
int app = yices_application(pDeclaration, argArray.length, argArray);
return app;
}
}
}
private int toInt(int termId) {
assert yices_term_is_int(termId);
return Integer.parseInt(yices_rational_const_value(termId));
}
private void checkArgsLength(String kind, List<Integer> pArgs, final int expectedLength) {
Preconditions.checkArgument(
pArgs.size() == expectedLength,
"%s with %s expected arguments was called with unexpected arguments: %s",
kind,
expectedLength,
Collections2.transform(pArgs, Yices2NativeApi::yices_term_to_string));
}
@Override
public Integer declareUFImpl(String pName, Integer pReturnType, List<Integer> pArgTypes) {
int size = pArgTypes.size();
int[] argTypeArray = Ints.toArray(pArgTypes);
final int yicesFuncType;
if (pArgTypes.isEmpty()) {
// a nullary function is a plain symbol (variable)
yicesFuncType = pReturnType;
} else {
yicesFuncType = yices_function_type(size, argTypeArray, pReturnType);
}
int uf = yices_named_variable(yicesFuncType, pName);
return uf;
}
@Override
protected Integer getBooleanVarDeclarationImpl(Integer pTFormulaInfo) {
return yices_term_constructor(pTFormulaInfo);
}
private Object parseNumeralValue(Integer pF, FormulaType<?> type) {
if (yices_term_constructor(pF) == YICES_ARITH_CONST) {
String value = yices_rational_const_value(pF);
if (type.isRationalType()) {
Rational ratValue = Rational.of(value);
return ratValue.isIntegral() ? ratValue.getNum() : ratValue;
} else if (type.isIntegerType()) {
return new BigInteger(value);
} else {
throw new IllegalArgumentException("Unexpected type: " + type);
}
} else {
throw new IllegalArgumentException(
String.format(
"Term: '%s' with type '%s' is not an arithmetic constant",
yices_term_to_string(pF), yices_type_to_string(yices_type_of_term(pF))));
}
}
private BigInteger parseBitvector(int pF) {
if (yices_term_constructor(pF) == YICES_BV_CONST) {
int[] littleEndianBV = yices_bv_const_value(pF, yices_term_bitsize(pF));
Preconditions.checkArgument(littleEndianBV.length != 0, "BV was empty");
String bigEndianBV = Joiner.on("").join(Lists.reverse(Ints.asList(littleEndianBV)));
return new BigInteger(bigEndianBV, 2);
} else {
throw new IllegalArgumentException(
String.format("Term: '%s' is not a bitvector constant", yices_term_to_string(pF)));
}
}
@Override
public Object convertValue(Integer typeKey, Integer pF) {
FormulaType<?> type = getFormulaType(typeKey);
if (type.isBooleanType()) {
return pF.equals(yices_true());
} else if (type.isRationalType() || type.isIntegerType()) {
return parseNumeralValue(pF, type);
} else if (type.isBitvectorType()) {
return parseBitvector(pF);
} else {
throw new IllegalArgumentException(
"Unexpected type: " + yices_type_to_string(yices_type_of_term(pF)));
}
}
}
| 33,601 | 43.743009 | 97 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2FormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
import static com.google.common.base.CharMatcher.inRange;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_APP_TERM;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvtype_size;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_parse_term;
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_to_string;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_type_children;
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_num_children;
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 com.google.common.base.CharMatcher;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import java.io.IOException;
import java.util.Locale;
import java.util.Map;
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.api.FormulaType;
import org.sosy_lab.java_smt.basicimpl.AbstractFormulaManager;
public class Yices2FormulaManager extends AbstractFormulaManager<Integer, Integer, Long, Integer> {
private static final CharMatcher LETTERS = inRange('a', 'z').or(inRange('A', 'Z'));
private static final CharMatcher DIGITS = inRange('0', '9');
private static final CharMatcher ADDITIONAL_CHARS = CharMatcher.anyOf("~!@$%^&*_-+=<>.?/");
private static final CharMatcher VALID_CHARS =
LETTERS.or(DIGITS).or(ADDITIONAL_CHARS).precomputed();
protected Yices2FormulaManager(
Yices2FormulaCreator pFormulaCreator,
Yices2UFManager pFunctionManager,
Yices2BooleanFormulaManager pBooleanManager,
Yices2IntegerFormulaManager pIntegerManager,
Yices2RationalFormulaManager pRationalManager,
Yices2BitvectorFormulaManager pBitvectorManager) {
super(
pFormulaCreator,
pFunctionManager,
pBooleanManager,
pIntegerManager,
pRationalManager,
pBitvectorManager,
null,
null,
null,
null,
null,
null);
}
static Integer getYicesTerm(Formula pT) {
return ((Yices2Formula) pT).getTerm();
}
@Override
public BooleanFormula parse(String pS) throws IllegalArgumentException {
// TODO Might expect Yices input language instead of smt-lib2 notation
return getFormulaCreator().encapsulateBoolean(yices_parse_term(pS));
}
@Override
public Appender dumpFormula(final Integer formula) {
assert getFormulaCreator().getFormulaType(formula) == FormulaType.BooleanType
: "Only BooleanFormulas may be dumped";
return new Appenders.AbstractAppender() {
@Override
public void appendTo(Appendable out) throws IOException {
Map<String, Formula> varsAndUFs =
extractVariablesAndUFs(getFormulaCreator().encapsulateWithTypeOf(formula));
for (Map.Entry<String, Formula> entry : varsAndUFs.entrySet()) {
final int term = ((Yices2Formula) entry.getValue()).getTerm();
final int type;
if (yices_term_constructor(term) == YICES_APP_TERM) {
// Is an UF. Correct type is carried by first child.
type = yices_type_of_term(yices_term_child(term, 0));
} else {
type = yices_type_of_term(term);
}
final int[] types;
if (yices_type_num_children(type) == 0) {
types = new int[] {type};
} else {
types = yices_type_children(type); // adds children types and then return type
}
if (types.length > 0) {
out.append("(declare-fun ");
out.append(quote(entry.getKey()));
out.append(" (");
for (int i = 0; i < types.length - 1; i++) {
out.append(getTypeRepr(types[i]));
if (i + 1 < types.length - 1) {
out.append(' ');
}
}
out.append(") ");
out.append(getTypeRepr(types[types.length - 1]));
out.append(")\n");
}
}
// TODO fold formula to avoid exp. overhead
out.append("(assert ").append(yices_term_to_string(formula)).append(")");
}
private String getTypeRepr(int type) {
if (yices_type_is_bitvector(type)) {
return "(_ BitVec " + yices_bvtype_size(type) + ")";
}
String typeRepr = yices_type_to_string(type);
return typeRepr.substring(0, 1).toUpperCase(Locale.getDefault()) + typeRepr.substring(1);
}
};
}
/**
* Quote symbols if required.
*
* <p>See http://smtlib.cs.uiowa.edu/papers/smt-lib-reference-v2.6-r2017-07-18.pdf, Section 3.1.
* "Symbols"
*/
private static String quote(String str) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(str));
Preconditions.checkArgument(CharMatcher.anyOf("|\\").matchesNoneOf(str));
Preconditions.checkArgument(!SMTLIB2_KEYWORDS.contains(str));
if (VALID_CHARS.matchesAllOf(str) && !DIGITS.matches(str.charAt(0))) {
// simple symbol
return str;
} else {
// quoted symbol
return "|" + str + "|";
}
}
}
| 5,919 | 38.205298 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2IntegerFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
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 java.math.BigDecimal;
import java.math.BigInteger;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
public class Yices2IntegerFormulaManager
extends Yices2NumeralFormulaManager<IntegerFormula, IntegerFormula>
implements IntegerFormulaManager {
Yices2IntegerFormulaManager(
Yices2FormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
}
@Override
protected int getNumeralType() {
return getFormulaCreator().getIntegerType();
}
@Override
protected Integer makeNumberImpl(double pNumber) {
return makeNumberImpl((long) pNumber);
}
@Override
protected Integer makeNumberImpl(BigDecimal pNumber) {
return decimalAsInteger(pNumber);
}
@Override
public Integer divide(Integer pParam1, Integer pParam2) {
if (isNumeral(pParam2)) {
return yices_idiv(pParam1, pParam2);
} else {
return super.divide(pParam1, pParam2);
}
}
@Override
public Integer modulo(Integer pParam1, Integer pParam2) {
if (isNumeral(pParam2)) {
return yices_imod(pParam1, pParam2);
} else {
return super.modulo(pParam1, pParam2);
}
}
@Override
protected Integer modularCongruence(Integer pNumber1, Integer pNumber2, BigInteger pModulo) {
return modularCongruence0(pNumber1, pNumber2, pModulo.toString());
}
@Override
protected Integer modularCongruence(Integer pNumber1, Integer pNumber2, long pModulo) {
return modularCongruence0(pNumber1, pNumber2, Long.toString(pModulo));
}
protected Integer modularCongruence0(Integer pNumber1, Integer pNumber2, String pModulo) {
// ((_ divisible n) x) <==> (= x (* n (div x n)))
int mod = makeNumberImpl(pModulo);
int sub = subtract(pNumber1, pNumber2);
int div = divide(sub, mod);
int mul = multiply(mod, div);
return equal(sub, mul);
}
}
| 2,408 | 29.1125 | 95 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2Model.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YVAL_BOOL;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YVAL_BV;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YVAL_FUNCTION;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YVAL_MAPPING;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YVAL_RATIONAL;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YVAL_SCALAR;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YVAL_TUPLE;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YVAL_UNKNOWN;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_application;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvtype_size;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_def_terms;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_eq;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_false;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_free_model;
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_get_value;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_get_value_as_term;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_model_to_string;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_parse_bvbin;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_parse_float;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_parse_rational;
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_children;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_type_is_arithmetic;
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_is_bool;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_type_is_int;
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_val_bitsize;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_val_expand_function;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_val_expand_mapping;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_val_function_arity;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_val_get_bool;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_val_get_bv;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_val_get_mpq;
import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.primitives.Ints;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.sosy_lab.common.rationals.Rational;
import org.sosy_lab.java_smt.basicimpl.AbstractModel;
public class Yices2Model extends AbstractModel<Integer, Integer, Long> {
private final long model;
private final Yices2TheoremProver prover;
private final Yices2FormulaCreator formulaCreator;
protected Yices2Model(long model, Yices2TheoremProver prover, Yices2FormulaCreator pCreator) {
super(prover, pCreator);
this.model = model;
this.prover = prover; // can be NULL for testing
this.formulaCreator = Preconditions.checkNotNull(pCreator);
}
@Override
public void close() {
if (!isClosed()) {
yices_free_model(model);
}
super.close();
}
@Override
public ImmutableList<ValueAssignment> asList() {
Preconditions.checkState(!isClosed());
Preconditions.checkState(!prover.isClosed(), "cannot use model after prover is closed");
List<Integer> complex =
ImmutableList.of(YVAL_SCALAR, YVAL_FUNCTION, YVAL_MAPPING, YVAL_UNKNOWN, YVAL_TUPLE);
ImmutableList.Builder<ValueAssignment> assignments = ImmutableList.builder();
int[] termsInModel = yices_def_terms(model);
for (int term : termsInModel) {
int[] yvalTag = yices_get_value(model, term);
if (!complex.contains(yvalTag[1])) { // TODO Switch with other if for less complex check?
assignments.add(getSimpleAssignment(term));
} else if (yvalTag[1] == YVAL_FUNCTION) {
assignments.addAll(getFunctionAssignment(term, yvalTag));
} else {
throw new UnsupportedOperationException("YVAL with unexpected tag: " + yvalTag[1]);
}
}
return assignments.build();
}
private ImmutableList<ValueAssignment> getFunctionAssignment(int t, int[] yval) {
ImmutableList.Builder<ValueAssignment> assignments = ImmutableList.builder();
int arity = yices_val_function_arity(model, yval[0], yval[1]);
int[] types = yices_type_children(yices_type_of_term(t));
int[] argTerms = new int[arity];
String name = yices_get_term_name(t);
int[] expandFun = yices_val_expand_function(model, yval[0], yval[1]);
for (int i = 2; i < expandFun.length - 1; i += 2) {
int[] expandMap;
if (expandFun[i + 1] == YVAL_MAPPING) {
expandMap = yices_val_expand_mapping(model, expandFun[i], arity, expandFun[i + 1]);
} else {
throw new IllegalArgumentException("Unexpected YVAL tag " + yval[1]);
}
List<Object> argumentInterpretation = new ArrayList<>();
for (int j = 0; j < expandMap.length - 2; j += 2) {
Object argValue = valueFromYval(expandMap[j], expandMap[j + 1], types[j / 2]);
argumentInterpretation.add(argValue);
argTerms[j / 2] = valueAsTerm(types[j / 2], argValue);
}
Object funValue =
valueFromYval(
expandMap[expandMap.length - 2],
expandMap[expandMap.length - 1],
types[types.length - 1]);
int valueTerm = valueAsTerm(types[types.length - 1], funValue);
int funApp = yices_application(t, arity, argTerms);
assignments.add(
new ValueAssignment(
creator.encapsulateWithTypeOf(funApp),
creator.encapsulateWithTypeOf(valueTerm),
creator.encapsulateBoolean(yices_eq(funApp, valueTerm)),
name,
funValue,
argumentInterpretation));
}
return assignments.build();
}
private ValueAssignment getSimpleAssignment(int t) {
List<Object> argumentInterpretation = new ArrayList<>();
int valueTerm = yices_get_value_as_term(model, t);
return new ValueAssignment(
creator.encapsulateWithTypeOf(t),
creator.encapsulateWithTypeOf(valueTerm),
creator.encapsulateBoolean(yices_eq(t, valueTerm)),
yices_get_term_name(t),
formulaCreator.convertValue(t, valueTerm),
argumentInterpretation);
}
private Object valueFromYval(int id, int tag, int type) {
if (tag == YVAL_BOOL) {
return yices_val_get_bool(model, id, tag);
} else if (tag == YVAL_RATIONAL) {
String value = yices_val_get_mpq(model, id, tag);
if (yices_type_is_int(type) && !value.contains("/")) {
return new BigInteger(value);
} else {
return Rational.of(value);
}
} else if (tag == YVAL_BV) {
int size = yices_val_bitsize(model, id, tag);
int[] littleEndianBV = yices_val_get_bv(model, id, size, tag);
Preconditions.checkArgument(littleEndianBV.length != 0, "BV was empty");
String bigEndianBV = Joiner.on("").join(Lists.reverse(Ints.asList(littleEndianBV)));
return new BigInteger(bigEndianBV, 2);
} else {
throw new IllegalArgumentException("Unexpected YVAL tag: " + tag);
}
}
private int valueAsTerm(int type, Object value) {
if (yices_type_is_bool(type)) {
if ((boolean) value) {
return yices_true();
} else {
return yices_false();
}
} else if (yices_type_is_arithmetic(type)) {
String val = value.toString();
if (val.contains("/")) {
return yices_parse_rational(val);
} else {
return yices_parse_float(val);
}
} else if (yices_type_is_bitvector(type)) {
BigInteger val = (BigInteger) value;
int bvSize = yices_bvtype_size(type);
String bits = val.toString(2);
assert bits.length() <= bvSize
: "numeral value " + val + " is out of range for size " + bvSize;
if (bits.length() < bvSize) {
bits = Strings.padStart(bits, bvSize, '0');
}
Preconditions.checkArgument(bits.length() == bvSize, "Bitvector has unexpected size.");
return yices_parse_bvbin(bits);
} else {
throw new IllegalArgumentException("Unexpected type: " + yices_type_to_string(type));
}
}
@Override
protected @Nullable Integer evalImpl(Integer pFormula) {
// TODO Can UF appear here?? // Built in Functions like "add" seem to be OK
Preconditions.checkState(!isClosed());
// TODO REENABLE after testing
// Preconditions.checkState(!prover.isClosed(), "cannot use model after prover is closed");
int val = yices_get_value_as_term(model, pFormula);
if (val == -1) {
throw new IllegalArgumentException(
"Could not evaluate Term: " + yices_term_to_string(pFormula));
}
return val;
}
@Override
public String toString() {
return yices_model_to_string(model);
}
}
| 10,296 | 44.561947 | 96 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2NativeApi.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
import java.util.function.Supplier;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.java_smt.basicimpl.ShutdownHook;
@SuppressWarnings({"unused", "checkstyle:methodname", "checkstyle:parametername"})
public class Yices2NativeApi {
private Yices2NativeApi() {}
// Yices2 status codes
public static final int YICES_STATUS_IDLE = 0;
public static final int YICES_STATUS_SEARCHING = 1;
public static final int YICES_STATUS_UNKNOWN = 2;
public static final int YICES_STATUS_SAT = 3;
public static final int YICES_STATUS_UNSAT = 4;
public static final int YICES_STATUS_INTERRUPTED = 5;
public static final int YICES_STATUS_ERROR = 6;
// Yices2 term constructors
public static final int YICES_CONSTRUCTOR_ERROR = -1;
public static final int YICES_BOOL_CONST = 0;
public static final int YICES_ARITH_CONST = 1;
public static final int YICES_BV_CONST = 2;
public static final int YICES_SCALAR_CONST = 3; // NOT used in JavaSMT
public static final int YICES_VARIABLE = 4;
public static final int YICES_UNINTERPRETED_TERM = 5;
public static final int YICES_ITE_TERM = 6; // if-then-else
public static final int YICES_APP_TERM = 7; // application of an uninterpreted function
public static final int YICES_UPDATE_TERM = 8; // function update
public static final int YICES_TUPLE_TERM = 9; // tuple constructor
public static final int YICES_EQ_TERM = 10; // equality
public static final int YICES_DISTINCT_TERM = 11; // distinct t_1 ... t_n
public static final int YICES_FORALL_TERM = 12; // quantifier
public static final int YICES_LAMBDA_TERM = 13; // lambda
public static final int YICES_NOT_TERM = 14; // (not t)
public static final int YICES_OR_TERM = 15; // n-ary OR
public static final int YICES_XOR_TERM = 16; // n-ary XOR
public static final int YICES_BV_ARRAY = 17; // array of boolean terms
public static final int YICES_BV_DIV = 18; // unsigned division
public static final int YICES_BV_REM = 19; // unsigned remainder
public static final int YICES_BV_SDIV = 20; // signed division
public static final int YICES_BV_SREM = 21; // remainder in signed division (rounding to 0)
public static final int YICES_BV_SMOD = 22; // remainder in signed division (rounding to
// -infinity)
public static final int YICES_BV_SHL = 23; // shift left (padding with 0)
public static final int YICES_BV_LSHR = 24; // logical shift right (padding with 0)
public static final int YICES_BV_ASHR = 25; // arithmetic shift right (padding with sign bit)
public static final int YICES_BV_GE_ATOM = 26; // unsigned comparison: (t1 >= t2)
public static final int YICES_BV_SGE_ATOM = 27; // signed comparison (t1 >= t2)
public static final int YICES_ARITH_GE_ATOM = 28; // atom (t1 >= t2) for arithmetic terms: t2 is
// always 0
public static final int YICES_ARITH_ROOT_ATOM = 29; // atom (0 <= k <= root_count(p)) && (x r
// root(p,k)) for r in <, <=, ==, !=, >, >=
public static final int YICES_ABS = 30; // absolute value
public static final int YICES_CEIL = 31; // ceil
public static final int YICES_FLOOR = 32; // floor
public static final int YICES_RDIV = 33; // real division (as in x/y)
public static final int YICES_IDIV = 34; // integer division
public static final int YICES_IMOD = 35; // modulo
public static final int YICES_IS_INT_ATOM = 36; // integrality test: (is-int t)
public static final int YICES_DIVIDES_ATOM = 37; // divisibility test: (divides t1 t2)
// projections
public static final int YICES_SELECT_TERM = 38; // tuple projection
public static final int YICES_BIT_TERM = 39; // bit-select: extract the i-th bit of a bitvector
// sums
public static final int YICES_BV_SUM = 40; // sum of pairs a * t where a is a bitvector constant
// (and t is a bitvector term)
public static final int YICES_ARITH_SUM = 41; // sum of pairs a * t where a is a rational (and t
// is an arithmetic term)
// products
public static final int YICES_POWER_PRODUCT = 42; // power products: (t1^d1 * ... * t_n^d_n)
// Workaround as Yices misses some useful operators,
// MAX_INT avoids collisions with existing constants
public static final int YICES_AND = Integer.MAX_VALUE - 1;
public static final int YICES_BV_MUL = Integer.MAX_VALUE - 2;
/*
* Yices model tags
*/
public static final int YVAL_UNKNOWN = 0;
public static final int YVAL_BOOL = 1;
public static final int YVAL_RATIONAL = 2;
public static final int YVAL_ALGEBRAIC = 3;
public static final int YVAL_BV = 4;
public static final int YVAL_SCALAR = 5;
public static final int YVAL_TUPLE = 6;
public static final int YVAL_FUNCTION = 7;
public static final int YVAL_MAPPING = 8;
/*
* Yices initialization and exit
*/
/** Initializes Yices data structures. Needs to be called before doing anything else. */
public static native void yices_init();
/** Call at the end to free memory allocated by Yices. */
public static native void yices_exit();
/**
* Perform a full reset of Yices
*
* <p>This function deletes all the terms and types defined in Yices and resets the symbol tables.
* It also deletes all contexts, models, configuration descriptors, and other records allocated in
* Yices.
*/
public static native void yices_reset();
/**
* Frees the specified String. Several API functions build and return a character string that is
* allocated by Yices. To avoid memory leaks, this string must be freed when it is no longer used
* by calling this function.
*
* @param stringPtr The pointer to the String
*/
public static native void free_string(long stringPtr);
/*
* Yices Version checking for test purposes
*/
public static native int yices_get_version();
public static native int yices_get_major_version();
public static native int yices_get_patch_level();
/*
* Context/ Environment creation
*/
public static native long yices_new_config();
public static native void yices_free_config(long cfg);
/**
* Set option to specified value.
*
* @param cfg The configuration to set the option in.
* @param option The option to set.
* @param value The value that the option will be set to.
*/
public static native void yices_set_config(long cfg, String option, String value);
/**
* Prepares a context configuration for the specified logic.
*
* @param cfg The configuration to be prepared
* @param logic Name of the logic to prepare for or "NULL"
* @return 0 if successful, -1 if an error occurred
*/
public static native int yices_default_config_for_logic(long cfg, String logic);
public static native long yices_new_context(long cfg);
public static native void yices_free_context(long ctx);
public static native void yices_context_enable_option(long ctx, String option);
public static native void yices_context_disable_option(long ctx, String option);
/*
* Yices search params
*/
public static native long yices_new_param_record();
public static native int yices_set_param(long record, String name, String value);
public static native void yices_default_params_for_context(long ctx, long record);
public static native void yices_free_param_record(long record);
/*
* Yices type construction
*/
public static native int yices_bool_type();
public static native int yices_int_type();
public static native int yices_real_type();
/**
* Constructs a bitvector type.
*
* @param size is the number of bits. It must be positive and no more than YICES_MAX_BVSIZE
* @return bitvector type
*/
public static native int yices_bv_type(int size);
/**
* Creates the function type (-> dom[0] … dom[n-1] range).
*
* @param n function arity (i.e., size of array dom)
* @param dom array of domain types
* @param range range type
* @return function type of n-arity
*/
public static native int yices_function_type(int n, int[] dom, int range);
/*
* Yices type tests
*/
public static native boolean yices_type_is_bool(int t);
public static native boolean yices_type_is_int(int t);
public static native boolean yices_type_is_real(int t);
/**
* Checks if type is arithmetic (i.e., either integer or real).
*
* @param t Type to check
* @return true if arithmetic, false otherwise
*/
public static native boolean yices_type_is_arithmetic(int t);
public static native boolean yices_type_is_bitvector(int t);
public static native boolean yices_type_is_function(int t);
/**
* Tests if the first type is a subtype of the second.
*
* @param t1 The first type
* @param t2 The second type
* @return true if t1 is a subtype of t2, otherwise false
*/
public static native boolean yices_test_subtype(int t1, int t2);
/**
* Tests if Type1 and Type2 are compatible.
*
* @param t1 The first type
* @param t2 The second type
* @return true if t1 and t2 are compatible, otherwise false
*/
public static native boolean yices_compatible_types(int t1, int t2);
/**
* Size of bitvector.
*
* @param t Bitvector to get the size of
* @return Number of bits in bitvector or 0 if an error occurred
*/
public static native int yices_bvtype_size(int t);
public static native int yices_type_num_children(int t);
public static native int yices_type_child(int t, int index);
public static native int[] yices_type_children(int t);
/*
* TERM CONSTRUCTION
*/
public static native int yices_new_uninterpreted_term(int type);
public static native int yices_new_variable(int type);
public static native int yices_constant(int type, int index);
public static native int yices_ite(int t_if, int t_then, int t_else);
public static native int yices_eq(int t_1, int t_2);
public static native int yices_neq(int t_1, int t_2);
public static native int yices_distinct(int size, int[] terms);
public static native int yices_application(int t, int size, int[] terms);
public static native int yices_update(int t1, int size, int[] terms, int t2);
public static native int yices_forall(int size, int[] terms, int t);
public static native int yices_exists(int size, int[] terms, int t);
public static native int yices_lambda(int size, int[] terms, int t);
/*
* Bool Terms
*/
public static native int yices_true();
public static native int yices_false();
public static native int yices_not(int t);
public static native int yices_and(int n, int[] arg);
public static native int yices_and2(int t1, int t2);
public static native int yices_and3(int t1, int t2, int t3);
public static native int yices_or(int n, int[] arg);
public static native int yices_or2(int t1, int t2);
public static native int yices_or3(int t1, int t2, int t3);
public static native int yices_xor(int n, int[] arg);
public static native int yices_xor2(int t1, int t2);
public static native int yices_xor3(int t1, int t2, int t3);
public static native int yices_iff(int t1, int t2);
public static native int yices_implies(int t1, int t2);
/*
* Arithmetic Terms
*/
public static native int yices_zero();
public static native int yices_int32(int value);
public static native int yices_int64(long val);
public static native int yices_rational32(int num, int den);
public static native int yices_rational64(long num, long den);
public static native int yices_parse_rational(String val);
public static native int yices_parse_float(String val);
public static native int yices_add(int t1, int t2);
public static native int yices_sub(int t1, int t2);
public static native int yices_neg(int t);
public static native int yices_mul(int t1, int t2);
public static native int yices_square(int t);
public static native int yices_power(int t, int power);
public static native int yices_division(int t1, int t2);
public static native int yices_sum(int size, int[] terms);
public static native int yices_product(int size, int[] terms);
public static native int yices_poly_int32(int size, int[] coeff, int[] terms);
public static native int yices_poly_int64(int size, long[] coeff, int[] terms);
public static native int yices_abs(int t);
public static native int yices_floor(int t);
public static native int yices_ceil(int t);
public static native int yices_idiv(int t1, int t2);
public static native int yices_imod(int t1, int t2);
public static native int yices_arith_eq_atom(int t1, int t2);
public static native int yices_arith_neq_atom(int t1, int t2);
public static native int yices_arith_geq_atom(int t1, int t2);
public static native int yices_arith_leq_atom(int t1, int t2);
public static native int yices_arith_gt_atom(int t1, int t2);
public static native int yices_arith_lt_atom(int t1, int t2);
public static native int yices_arith_eq0_atom(int t);
public static native int yices_arith_neq0_atom(int t);
public static native int yices_arith_geq0_atom(int t);
public static native int yices_arith_leq0_atom(int t);
public static native int yices_arith_gt0_atom(int t);
public static native int yices_arith_lt0_atom(int t);
public static native int yices_divides_atom(int t1, int t2);
public static native int yices_is_int_atom(int t);
/*
* Bitvector Terms
*/
public static native int yices_bvconst_uint32(int size, int value);
public static native int yices_bvcinst_uint64(int size, long value);
public static native int yices_bvconst_int32(int size, int value);
public static native int yices_bvconst_int64(int size, long value);
public static native int yices_bvconst_zero(int size);
public static native int yices_bvconst_one(int size);
public static native int yices_bvconst_minus_one(int size);
/**
* Parses the given Array in little endian order values[0] becomes the least significant bit.
* values[size-1] becomes the most significant bit.
*/
public static native int yices_bvconst_from_array(int size, int[] values);
public static native int yices_parse_bvbin(String value);
public static native int yices_parse_bvhex(String value);
public static native int yices_bvadd(int t1, int t2);
public static native int yices_bvsub(int t1, int t2);
public static native int yices_bvneg(int t);
public static native int yices_bvmul(int t1, int t2);
public static native int yices_bvsquare(int t);
public static native int yices_bvpower(int t, int power);
public static native int yices_bvsum(int size, int[] terms);
public static native int yices_bvproduct(int size, int[] terms);
public static native int yices_bvdiv(int t1, int t2);
public static native int yices_bvrem(int t1, int t2);
public static native int yices_bvsdiv(int t1, int t2);
public static native int yices_bvsrem(int t1, int t2);
public static native int yices_bvsmod(int t1, int t2);
public static native int yices_bvnot(int t);
public static native int yices_bvand(int size, int[] terms);
public static native int yices_bvand2(int t1, int t2);
public static native int yices_bvand3(int t1, int t2, int t3);
public static native int yices_bvor(int size, int[] terms);
public static native int yices_bvor2(int t1, int t2);
public static native int yices_bvor3(int t1, int t2, int t3);
public static native int yices_bvxor(int size, int[] terms);
public static native int yices_bvxor2(int t1, int t2);
public static native int yices_bvxor3(int t1, int t2, int t3);
public static native int yices_bvnand(int t1, int t2);
public static native int yices_bvnor(int t1, int t2);
public static native int yices_bvxnor(int t1, int t2);
public static native int yices_shift_left0(int t, int shift);
public static native int yices_shift_left1(int t, int shift);
public static native int yices_shift_right0(int t, int shift);
public static native int yices_shift_right1(int t, int shift);
public static native int yices_ashift_right(int t, int shift);
public static native int yices_rotate_left(int t, int shift);
public static native int yices_rotate_right(int t, int shift);
public static native int yices_bvshl(int t1, int t2);
public static native int yices_bvlshr(int t1, int t2);
public static native int yices_bvashr(int t1, int t2);
public static native int yices_bvextract(int t, int limit1, int limit2);
public static native int yices_bitextract(int t, int pos);
public static native int yices_bvconcat(int size, int[] terms);
public static native int yices_bvconcat2(int t1, int t2);
public static native int yices_bvrepeat(int t, int times);
public static native int yices_sign_extend(int t, int times);
public static native int yices_zero_extend(int t, int times);
public static native int yices_redand(int t);
public static native int yices_redor(int t);
public static native int yices_redcomp(int t1, int t2);
public static native int yices_bvarray(int size, int[] terms);
public static native int yices_bveq_atom(int t1, int t2);
public static native int yices_bvneq_atom(int t1, int t2);
public static native int yices_bvge_atom(int t1, int t2);
public static native int yices_bvgt_atom(int t1, int t2);
public static native int yices_bvle_atom(int t1, int t2);
public static native int yices_bvlt_atom(int t1, int t2);
public static native int yices_bvsge_atom(int t1, int t2);
public static native int yices_bvsgt_atom(int t1, int t2);
public static native int yices_bvsle_atom(int t1, int t2);
public static native int yices_bvslt_atom(int t1, int t2);
/*
* Term properties
*/
public static native int yices_type_of_term(int t);
public static native boolean yices_term_is_bool(int t);
public static native boolean yices_term_is_int(int t);
public static native boolean yices_term_is_real(int t);
public static native boolean yices_term_is_arithmetic(int t);
public static native boolean yices_term_is_bitvector(int t);
public static native boolean yices_term_is_function(int t);
public static native int yices_term_bitsize(int t);
public static native boolean yices_term_is_ground(int t);
public static native boolean yices_term_is_atomic(int t);
public static native boolean yices_term_is_composite(int t);
public static native boolean yices_term_is_projection(int t);
public static native boolean yices_term_is_sum(int t);
public static native boolean yices_term_is_bvsum(int t);
public static native boolean yices_term_is_product(int t);
public static native int yices_term_constructor(int t);
public static native int yices_term_num_children(int t);
public static native int yices_term_child(int t, int index);
public static native int yices_proj_index(int t);
public static native int yices_proj_arg(int t);
public static native boolean yices_bool_const_value(int t);
// TODO Return bool[] instead of int[]?
/** Returns in little endian order. */
public static native int[] yices_bv_const_value(int t, int bitsize);
public static native String yices_rational_const_value(int t);
/**
* Returns i-th sum component of term t as String-Array [coefficient, term]. If t is in a form
* like 3+x, for i = 0 the returned term will be -1/NULL_TERM.
*/
public static native String[] yices_sum_component(int t, int i);
/**
* Returns the i-th component of a bvsum. Returned array has length bitsize+1. array[0] to
* array[array.length-2] contain the coefficient, array[array.length-1] the term. If the t is in a
* form like [101]+x, for i = 0, the returned term will be -1/NULL_TERM.
*/
public static native int[] yices_bvsum_component(int t, int i, int bitsize);
// TODO can return up to UINT32_MAX ?
/** Returns an array in the form [term,power]. */
public static native int[] yices_product_component(int t, int i);
/*
* SAT Checking
*/
public static native int yices_context_status(long ctx);
public static native void yices_assert_formula(long ctx, int f);
public static native void yices_assert_formulas(long ctx, int size, int[] formulas);
/**
* @param params Set to 0 for default search parameters.
*/
public static native int yices_check_context(long ctx, long params);
public static native void yices_stop_search(long ctx);
public static native void yices_reset_context(long ctx);
public static native int yices_assert_blocking_clause(long ctx);
public static native void yices_push(long ctx);
public static native void yices_pop(long ctx);
/**
* @param params Set to 0 for default search parameters.
*/
public static native int yices_check_context_with_assumptions(
long ctx, long params, int size, int[] terms);
public static native int[] yices_get_unsat_core(long ctx);
/**
* @param params Set to 0 for default search parameters.
*/
public static boolean yices_check_sat(long ctx, long params, ShutdownNotifier shutdownNotifier)
throws IllegalStateException, InterruptedException {
return satCheckWithShutdownNotifier(
() -> yices_check_context(ctx, params), ctx, shutdownNotifier);
}
/**
* @param params Set to 0 for default search parameters.
*/
public static boolean yices_check_sat_with_assumptions(
long ctx, long params, int size, int[] assumptions, ShutdownNotifier shutdownNotifier)
throws InterruptedException {
return satCheckWithShutdownNotifier(
() -> yices_check_context_with_assumptions(ctx, params, size, assumptions),
ctx,
shutdownNotifier);
}
@SuppressWarnings("try")
private static boolean satCheckWithShutdownNotifier(
Supplier<Integer> satCheck, long pCtx, ShutdownNotifier shutdownNotifier)
throws InterruptedException {
int result;
try (ShutdownHook hook = new ShutdownHook(shutdownNotifier, () -> yices_stop_search(pCtx))) {
shutdownNotifier.shutdownIfNecessary();
result = satCheck.get(); // the expensive computation
}
shutdownNotifier.shutdownIfNecessary();
return check_result(result);
}
private static boolean check_result(int result) {
switch (result) {
case YICES_STATUS_SAT:
return true;
case YICES_STATUS_UNSAT:
return false;
default:
// TODO Further ERROR CLARIFICATION
String code = (result == YICES_STATUS_UNKNOWN) ? "\"unknown\"" : result + "";
throw new IllegalStateException("Yices check returned:" + code);
}
}
/*
* Model generation and exploration
*/
public static native long yices_get_model(long ctx, int keepSubst);
public static native long yices_model_from_map(int size, int[] var, int[] constant);
/*
* renamed collect_defined_terms to def_terms as it caused an UnsatisfiedLinkError for some reason
*/
public static native int[] yices_def_terms(long model); // collect_defined_terms(long model);
public static native void yices_free_model(long model);
/** get the value of a term as pair [node_id, node_tag]. */
public static native int[] yices_get_value(long m, int t);
public static native int yices_val_bitsize(long m, int id, int tag);
public static native int yices_val_function_arity(long m, int id, int tag);
public static native boolean yices_val_get_bool(long m, int id, int tag);
public static native String yices_val_get_mpq(long m, int id, int tag);
/*
* node_id / node_tag separated to preserve C call order
* Returns in little endian order
*/
public static native int[] yices_val_get_bv(long m, int id, int size, int tag);
/**
* Returns array of yval_t values built like this: [yval_t.node_id, yval_t.node_tag,
* yval_t.node_id, yval_t.node_tag, ...]. The first pair of values represent the default value,
* the following values should represent mappings, which can be expanded using expand_mapping().
*/
public static native int[] yices_val_expand_function(long m, int id, int tag);
/**
* Returns array of yval_t values built like this: [yval_t.node_id, yval_t.node_tag,
* yval_t.node_id, yval_t.node_tag, ...]. The last pair of values represent the function's value,
* the other pairs are values for the function's arguments. node_id / node_tag separated to
* preserve C call order
*/
public static native int[] yices_val_expand_mapping(long m, int id, int arity, int tag);
/** get the value of a term as (constant) term. */
public static native int yices_get_value_as_term(long m, int t);
public static native void yices_set_term_name(int t, String name);
public static native String yices_get_term_name(int t);
public static native int yices_get_term_by_name(String name);
/**
* Use to print a term in a readable format. Result will be truncated if height/width of the
* String are too small.
*
* @param t The term to print
* @param width The width of the resulting String
* @param height The height/lines of resulting String
*/
private static native String yices_term_to_string(int t, int width, int height, int offset);
private static native String yices_type_to_string(int t, int width, int height, int offset);
private static native String yices_model_to_string(long m, int width, int height, int offset);
public static String yices_term_to_string(int t) {
return yices_term_to_string(t, Integer.MAX_VALUE, 1, 0);
}
public static String yices_type_to_string(int t) {
return yices_type_to_string(t, Integer.MAX_VALUE, 1, 0);
}
public static String yices_model_to_string(long m) {
return yices_model_to_string(m, Integer.MAX_VALUE, 1, 0);
}
/**
* Parse a single expression/term in SMTLIB2-based Yices input language.
*
* <p>Declarations of symbols not are allowed. All symbols must already be known.
*/
public static native int yices_parse_term(String t);
public static native int yices_subst_term(int size, int[] from, int[] to, int t);
public static int yices_named_variable(int type, String name) {
int termFromName = yices_get_term_by_name(name);
if (termFromName != -1) {
int termFromNameType = yices_type_of_term(termFromName);
if (type == termFromNameType) {
return termFromName;
} else {
throw new IllegalArgumentException(
String.format(
"Can't create variable with name '%s' and type '%s' "
+ "as it would omit a variable with type '%s'",
name, yices_type_to_string(type), yices_type_to_string(termFromNameType)));
}
}
int var = yices_new_uninterpreted_term(type);
yices_set_term_name(var, name);
return var;
}
/**
* @return int 1 if the Yices2-lib is compiled thread-safe and 0 otherwise
*/
public static native int yices_is_thread_safe();
/** The function first checks whether f is satisifiable or unsatisfiable. */
public static native int yices_check_formula(int term, String logic, long model, String delegate);
/**
* This is similar to yices_check_formula except that it checks whether the conjunction of f[0]
* ... f[n-1] is satisfiable.
*/
public static native int yices_check_formulas(
int[] terms, int n, String logic, long model, String delegate);
/**
* @return int 1 if delegate(SAT-Solver) available for use, 0 otherwise
*/
public static native int yices_has_delegate(String delegate);
/**
* @return type of a function node
*/
public static native int yices_val_function_type(long model, int id, int tag);
/**
* @return term_vector (NOT int with error code) that is supported. Empty if error!
*/
public static native int[] yices_model_term_support(long model, int term);
}
| 28,018 | 32.555689 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2NativeApiTest.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
import static com.google.common.truth.Truth.assertThat;
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_SUM;
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_SUM;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_EQ_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_STATUS_SAT;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YVAL_RATIONAL;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_add;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_and;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_and2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_application;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_arith_eq_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_arith_gt_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_arith_lt_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_assert_formula;
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_bvadd;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvand2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvconst_int64;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvconst_minus_one;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvconst_one;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bveq_atom;
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_bvsum_component;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_bvxor2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_check_context;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_context_disable_option;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_def_terms;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_eq;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_exit;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_false;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_free_config;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_free_context;
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_model;
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_get_value;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_idiv;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_iff;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_init;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_int32;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_int64;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_int_type;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_model_to_string;
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_new_config;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_new_context;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_new_uninterpreted_term;
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_or2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_parse_bvbin;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_parse_rational;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_parse_term;
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_push;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_rational32;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_real_type;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_redand;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_set_config;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_set_term_name;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_sign_extend;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_sub;
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_bool;
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_val_get_mpq;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_zero_extend;
import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.primitives.Ints;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.After;
import org.junit.AssumptionViolatedException;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.sosy_lab.common.NativeLibraries;
import org.sosy_lab.common.rationals.Rational;
import org.sosy_lab.java_smt.api.Model;
@SuppressWarnings("unused")
public class Yices2NativeApiTest {
private static final int SAT = 3;
private static final int UNSAT = 4;
@BeforeClass
public static void loadYices() {
try {
NativeLibraries.loadLibrary("yices2j");
} catch (UnsatisfiedLinkError e) {
throw new AssumptionViolatedException("Yices2 is not available", e);
}
}
private long env;
@Before
public void createEnvironment() {
yices_init();
long cfg = yices_new_config();
yices_set_config(cfg, "solver-type", "dpllt");
yices_set_config(cfg, "mode", "push-pop");
env = yices_new_context(cfg);
yices_context_disable_option(env, "var-elim");
yices_free_config(cfg);
}
@After
public void freeEnvironment() {
yices_free_context(env);
yices_exit();
}
@Test
public void simpleUNSAT() {
int termTrue = yices_true();
int termFalse = yices_false();
int formula = yices_and2(termTrue, termFalse);
yices_assert_formula(env, formula);
assertThat(yices_check_context(env, 0)).isEqualTo(UNSAT);
}
@Test
public void simpleSAT() {
int termTrue = yices_true();
int formula = yices_and2(termTrue, termTrue);
yices_assert_formula(env, formula);
assertThat(yices_check_context(env, 0)).isEqualTo(SAT);
}
/*
* 3=SAT 4=UNSAT
*/
@Test
public void arrayArgSAT() {
int n = 4;
int termTrue = yices_true();
int[] terms = {termTrue, termTrue, termTrue, termTrue};
int formula = yices_and(n, terms);
yices_assert_formula(env, formula);
assertThat(yices_check_context(env, 0)).isEqualTo(SAT);
}
@Test
public void arrayArgUNSAT() {
int n = 4;
int termTrue = yices_true();
int termFalse = yices_false();
int[] terms = {termFalse, termTrue, termTrue, termTrue};
int formula = yices_and(n, terms);
yices_assert_formula(env, formula);
assertThat(yices_check_context(env, 0)).isEqualTo(UNSAT);
}
@Test
public void arithAddSAT() {
int one = yices_int32(1);
int two = yices_int32(2);
int three = yices_int32(3);
int add = yices_add(one, two);
int equal = yices_eq(three, add);
yices_assert_formula(env, equal);
assertThat(yices_check_context(env, 0)).isEqualTo(SAT);
}
@Test
public void arithAddUNSAT() {
int one = yices_int32(1);
int two = yices_int32(99);
int three = yices_int32(3);
int add = yices_add(one, two);
int equal = yices_eq(three, add);
yices_assert_formula(env, equal);
assertThat(yices_check_context(env, 0)).isEqualTo(UNSAT);
}
@Test(expected = IllegalArgumentException.class)
public void rationalError() {
int rat = yices_rational32(1, 0);
System.out.println(rat); // "use" variable
}
@Test
public void negativeRationalError() {
// TODO negative unsigned integer causes no error. Need to ensure positive value before
int rat = yices_rational32(1, -5);
System.out.println(rat); // "use" variable
}
@Test(expected = IllegalArgumentException.class)
public void wrongType() {
int one = yices_int32(1);
int bitsize = yices_term_bitsize(one);
System.out.println(bitsize); // "use" variable
}
@Test
public void testRange() {
int intmax = yices_int32(Integer.MAX_VALUE);
int longmax = yices_int64(Long.MAX_VALUE);
int gt = yices_arith_gt_atom(longmax, intmax);
yices_assert_formula(env, gt);
assertThat(yices_check_context(env, 0)).isEqualTo(SAT);
}
@Test
public void simpleBitvectorSAT() {
int v1 = yices_parse_bvbin("01010");
int v2 = yices_parse_bvbin("10101");
int v3 = yices_bvconst_one(1);
int f1 = yices_bvxor2(v1, v2);
int f2 = yices_redand(f1);
int f3 = yices_bveq_atom(f2, v3);
yices_assert_formula(env, f3);
assertThat(yices_check_context(env, 0)).isEqualTo(SAT);
}
@Test
public void simpleBitvectorUNSAT() {
int v1 = yices_parse_bvbin("01010");
int v2 = yices_parse_bvbin("10101");
int v3 = yices_bvconst_one(1);
int f1 = yices_bvand2(v1, v2);
int f2 = yices_redand(f1);
int f3 = yices_bveq_atom(f2, v3);
yices_assert_formula(env, f3);
assertThat(yices_check_context(env, 0)).isEqualTo(UNSAT);
}
@Test
public void boolValueQuery() {
int v1 = yices_true();
int v2 = yices_false();
assertThat(yices_bool_const_value(v1)).isTrue();
assertThat(yices_bool_const_value(v2)).isFalse();
}
@SuppressWarnings("CheckReturnValue")
@Test(expected = IllegalArgumentException.class)
public void boolValueTypeMismatch() {
int v1 = yices_int32(45);
yices_bool_const_value(v1);
}
@Test
public void bitvectorReturn() {
int bv1 = yices_parse_bvbin("111000");
int[] bvComp = {0, 0, 0, 1, 1, 1};
int bvsize = yices_term_bitsize(bv1);
assertThat(bvsize).isEqualTo(6);
int[] bvReturn = yices_bv_const_value(bv1, bvsize);
assertThat(bvComp).isEqualTo(bvReturn);
}
@Test
public void rationalValueTest() {
int num = 35975;
int den = 1234567890;
int negativeNum = -50;
int negativeDen = -30000;
BigInteger largeNumber = BigInteger.valueOf(2).pow(10000);
int ratConst = yices_rational32(num, den);
int negativeNumConst = yices_parse_rational(negativeNum + "/" + den);
int negativeDenConst = yices_parse_rational(num + "/" + negativeDen);
int negativeNumDenConst = yices_parse_rational(negativeNum + "/" + negativeDen);
int bigConst = yices_parse_rational(largeNumber.toString());
Yices2FormulaCreator creator = new Yices2FormulaCreator();
assertThat(creator.convertValue(ratConst, ratConst)).isEqualTo(Rational.of(num + "/" + den));
assertThat(creator.convertValue(bigConst, bigConst)).isEqualTo(largeNumber);
assertThat(creator.convertValue(negativeNumConst, negativeNumConst))
.isEqualTo(Rational.of(negativeNum + "/" + den));
assertThat(creator.convertValue(negativeDenConst, negativeDenConst))
.isEqualTo(Rational.of(num + "/" + negativeDen));
assertThat(creator.convertValue(negativeNumDenConst, negativeNumDenConst))
.isEqualTo(Rational.of(negativeNum + "/" + negativeDen));
}
@Test
public void bvValueTest() {
int value = 14;
int bv = yices_bvconst_int64(4, value);
if (yices_term_constructor(bv) == YICES_BV_CONST) {
int[] littleEndianBV = yices_bv_const_value(bv, yices_term_bitsize(bv));
Preconditions.checkArgument(littleEndianBV.length != 0, "BV was empty");
String bigEndianBV = Joiner.on("").join(Lists.reverse(Ints.asList(littleEndianBV)));
BigInteger big = new BigInteger(bigEndianBV, 2);
assertThat(big).isEqualTo(BigInteger.valueOf(value));
}
}
@Test
public void termNaming() {
int t = yices_parse_bvbin("0100100001100101011011000110110001101111");
String termName = "Hello";
yices_set_term_name(t, termName);
assertThat(yices_get_term_name(t)).isEqualTo(termName);
}
@Test
public void satWithVariable() {
int termFalse = yices_false();
int var = yices_new_uninterpreted_term(yices_bool_type());
int formula = yices_or2(termFalse, var);
yices_assert_formula(env, formula);
assertThat(yices_check_context(env, 0)).isEqualTo(SAT);
}
// Yices converts add(YICES_ARITH_CONST, YICES_ARITH_CONST) to an YICES_ARITH_CONST
// Yices converts add(YICES_ARITH_CONST, YICES_UNINTERPRETED_TERM) to YICES_ARITH_SUM
@Test
public void termConstructorAdd() {
int one = yices_int32(1);
int two = yices_new_uninterpreted_term(yices_int_type()); // yices_int32(2);
int addition = yices_add(one, two);
assertThat(yices_term_constructor(addition)).isEqualTo(YICES_ARITH_SUM);
}
@Test
public void termConstructorAnd() {
// and 1 2 is replaced with not (or (not 1) (not 2))
int termTrue = yices_new_uninterpreted_term(yices_bool_type()); // yices_true();
yices_set_term_name(termTrue, "termTrue");
int termTwo = yices_new_uninterpreted_term(yices_bool_type());
yices_set_term_name(termTwo, "termTwo");
int and = yices_and2(termTrue, termTwo);
int child = yices_term_child(and, 0);
assertThat(yices_term_constructor(child)).isEqualTo(YICES_OR_TERM);
assertThat(yices_term_num_children(child)).isEqualTo(2);
assertThat(yices_term_to_string(and)).isEqualTo("(and termTrue termTwo)");
assertThat(yices_term_constructor(and)).isEqualTo(YICES_NOT_TERM);
}
@Test
public void termConstructorOr() {
int termFalse = yices_new_uninterpreted_term(yices_bool_type()); // yices_false();
// yices_set_term_name(termFalse, "1");
int two = yices_new_uninterpreted_term(yices_bool_type());
// yices_set_term_name(two, "5");
int[] orArray = {termFalse, two, termFalse, termFalse};
int or = yices_or(4, orArray);
assertThat(yices_term_is_bool(or)).isTrue();
assertThat(yices_term_constructor(or)).isEqualTo(YICES_OR_TERM);
// Works after changing something?
} // Expecting YICES_OR_TERM as constructor but getting YICES_UNINTERPRETED_TERM
@Test
public void termConstructorNot() {
int termTrue = yices_new_uninterpreted_term(yices_bool_type()); // yices_true();
yices_set_term_name(termTrue, "termTrue");
int termTwo = yices_new_uninterpreted_term(yices_bool_type());
yices_set_term_name(termTwo, "termTwo");
int not = yices_not(termTrue);
assertThat(yices_term_constructor(not)).isEqualTo(YICES_NOT_TERM);
}
@Test
public void modularCongruence() {
int pNumber1 = yices_int32(9);
int pNumber2 = yices_int32(5);
int mod = yices_int32(4);
int subTerm = yices_sub(pNumber1, pNumber2);
int div = yices_idiv(subTerm, mod);
int mul = yices_mul(mod, div);
int eq = yices_arith_eq_atom(subTerm, mul);
assertThat(eq).isEqualTo(yices_true());
}
@Test
public void orSimplification() {
int termTrue = yices_true();
int boolType = yices_bool_type();
int[] orArray = new int[20];
for (int i = 0; i < (orArray.length - 1); i++) {
orArray[i] = yices_named_variable(boolType, "x" + i);
}
orArray[(orArray.length - 1)] = termTrue;
int or = yices_or(orArray.length, orArray);
assertThat(or).isEqualTo(yices_true());
}
@Test
public void andSimplification() {
int termFalse = yices_false();
int boolType = yices_bool_type();
int[] andArray = new int[20];
for (int i = 0; i < (andArray.length - 1); i++) {
andArray[i] = yices_named_variable(boolType, "x" + i);
}
andArray[(andArray.length - 1)] = termFalse;
int and = yices_and(andArray.length, andArray);
assertThat(and).isEqualTo(yices_false());
}
@Test
public void iffConstructor() {
int one = yices_new_uninterpreted_term(yices_bool_type());
int two = yices_new_uninterpreted_term(yices_bool_type());
int iff = yices_iff(one, two);
assertThat(yices_term_constructor(iff)).isEqualTo(YICES_EQ_TERM);
}
@Test
public void ufConstructor() {
int funType = yices_function_type(1, new int[] {yices_int_type()}, yices_bool_type());
int uf = yices_named_variable(funType, "uf");
int[] argArray = new int[] {yices_int32(123)};
int app = yices_application(uf, argArray.length, argArray);
assertThat(yices_term_constructor(app)).isEqualTo(YICES_APP_TERM);
}
@Test
public void uf2Constructor() {
int funType =
yices_function_type(2, new int[] {yices_int_type(), yices_int_type()}, yices_int_type());
int uf = yices_named_variable(funType, "uf");
int[] argArray = new int[] {yices_int32(123), yices_int32(456)};
int app = yices_application(uf, argArray.length, argArray);
assertThat(yices_term_constructor(app)).isEqualTo(YICES_APP_TERM);
}
@SuppressWarnings("resource")
@Test
public void modelTest() {
int varx = yices_named_variable(yices_real_type(), "x");
int eq = yices_arith_eq_atom(varx, yices_int32(10));
int query = yices_named_variable(yices_real_type(), "x");
Yices2FormulaCreator creator = new Yices2FormulaCreator();
yices_push(env);
yices_assert_formula(env, eq);
System.out.println("varx: " + varx);
System.out.println("query: " + query);
if (yices_check_context(env, 0) == YICES_STATUS_SAT) {
Model m = new Yices2Model(yices_get_model(env, 1), null, creator);
Object val = m.evaluate(creator.encapsulateWithTypeOf(varx));
System.out.println(val);
m.close();
}
}
@SuppressWarnings("resource")
@Test
public void modelExplorationTest() {
int x = yices_int32(5);
int y = yices_int32(7);
int z = yices_named_variable(yices_int_type(), "z");
int gt = yices_arith_gt_atom(z, x);
int lt = yices_arith_lt_atom(z, y);
int x2 = yices_int32(333);
int y2 = yices_int32(335);
int z2 = yices_named_variable(yices_int_type(), "z2");
int gt2 = yices_arith_gt_atom(z2, x2);
int lt2 = yices_arith_lt_atom(z2, y2);
int sub = yices_sub(z2, z);
int eq = yices_arith_eq_atom(sub, yices_int32(328));
Yices2FormulaCreator creator = new Yices2FormulaCreator();
yices_push(env);
yices_assert_formula(env, gt);
yices_assert_formula(env, lt);
yices_assert_formula(env, gt2);
yices_assert_formula(env, lt2);
yices_assert_formula(env, eq);
if (yices_check_context(env, 0) == YICES_STATUS_SAT) {
long model = yices_get_model(env, 1);
Model m = new Yices2Model(model, null, creator);
System.out.println(yices_model_to_string(model));
Object val = m.evaluate(creator.encapsulateWithTypeOf(eq));
System.out.println(val);
int addT = yices_add(z, z2);
Object val2 = m.evaluate(creator.encapsulateWithTypeOf(addT));
System.out.println(val2);
System.out.println("DEFINED TERMS");
int[] terms = yices_def_terms(model);
for (int term : terms) {
System.out.println(yices_term_to_string(term));
System.out.println("Term id is: " + term);
int[] yval = yices_get_value(model, term);
System.out.println("Node id is: " + yval[0]);
System.out.println("Node tag is: " + yval[1]);
if (yval[1] == YVAL_RATIONAL) {
System.out.println("Value is: " + yices_val_get_mpq(model, yval[0], yval[1]));
}
}
m.close();
} else {
throw new IllegalArgumentException("The environment is not solvable!");
}
}
@Test
public void parseTerm() {
// int x = yices_parse_term("define x::int");
// int y = yices_parse_term("define y::int");
// int xsmallery = yices_parse_term("assert (< x y)");
// int xbigger4 = yices_parse_term("assert (> x 4)");
// int ysmaller7 = yices_parse_term("assert (< y 7)");
// assertThat(yices_check_context(env, 0), SAT);
int y = yices_int32(5);
yices_set_term_name(y, "y");
int x = yices_parse_term("(/= y 5)");
assertThat(yices_term_to_string(x)).isEqualTo("false");
}
@Test
public void arithSimplification() {
int x = yices_int32(6);
int y = yices_int32(7);
int add = yices_add(x, y);
int mul = yices_mul(x, y);
Yices2FormulaCreator creator = new Yices2FormulaCreator();
assertThat(creator.convertValue(add, add)).isEqualTo(BigInteger.valueOf(13));
assertThat(yices_term_constructor(add)).isEqualTo(YICES_ARITH_CONST);
assertThat(creator.convertValue(mul, mul)).isEqualTo(BigInteger.valueOf(42));
assertThat(yices_term_constructor(mul)).isEqualTo(YICES_ARITH_CONST);
}
@Test
public void sumComponents() {
int three = yices_int32(3);
int rat = yices_parse_rational("3/2");
int x = yices_named_variable(yices_int_type(), "x");
int[] oneX = {three, x};
int sumOneX = yices_sum(2, oneX);
for (int i = 0; i < yices_term_num_children(sumOneX); i++) {
System.out.println(yices_term_to_string(sumOneX));
System.out.println(Arrays.toString(yices_sum_component(sumOneX, i)));
}
int[] twoX = {three, x, x};
int sumTwoX = yices_sum(3, twoX);
for (int i = 0; i < yices_term_num_children(sumTwoX); i++) {
System.out.println(yices_term_to_string(sumTwoX));
System.out.println(Arrays.toString(yices_sum_component(sumTwoX, i)));
}
int[] twoThrees = {three, x, three};
int sumTwoThrees = yices_sum(3, twoThrees);
for (int i = 0; i < yices_term_num_children(sumTwoThrees); i++) {
System.out.println(yices_term_to_string(sumTwoThrees));
System.out.println(Arrays.toString(yices_sum_component(sumTwoThrees, i)));
}
int xTimesRational = yices_mul(rat, x);
int[] ratSum = {three, xTimesRational};
int sumRatX = yices_sum(2, ratSum);
for (int i = 0; i < yices_term_num_children(sumRatX); i++) {
System.out.println(yices_term_to_string(sumRatX));
System.out.println(Arrays.toString(yices_sum_component(sumRatX, i)));
}
}
@Test
public void bvSumComponents() {
int bv1 = yices_parse_bvbin("00101");
int bv5type = yices_bv_type(5);
int x = yices_named_variable(bv5type, "x");
int negativeX = yices_bvmul(yices_bvconst_minus_one(5), x);
int add = yices_bvadd(bv1, negativeX);
for (int i = 0; i < yices_term_num_children(add); i++) {
System.out.println(yices_term_to_string(add));
int[] component = yices_bvsum_component(add, i, yices_term_bitsize(add));
String value =
Joiner.on("")
.join(
Lists.reverse(
Ints.asList(Arrays.copyOfRange(component, 0, component.length - 1))));
int term = component[component.length - 1];
System.out.println("Value of coefficient: " + value);
System.out.println("Coefficient as BigInt: " + new BigInteger(value, 2));
System.out.println("Term id: " + term);
}
}
@Test
public void bvExtensionStructureTest() {
int extendBy = 5;
int x = yices_named_variable(yices_bv_type(5), "x");
List<Integer> terms = new ArrayList<>();
terms.add(yices_sign_extend(x, extendBy));
terms.add(yices_sign_extend(x, extendBy));
terms.add(yices_zero_extend(x, extendBy));
terms.add(yices_zero_extend(x, extendBy));
for (int t : terms) {
System.out.println("--------BEGIN-------");
System.out.println(yices_term_to_string(t));
for (int i = 0; i < yices_term_num_children(t); i++) {
System.out.println(yices_term_to_string(yices_term_child(t, i)));
}
int bv = yices_proj_arg(yices_term_child(t, 0));
int bvSize = yices_term_bitsize(bv);
int extendedBy = yices_term_num_children(t) - bvSize;
System.out.println("Extended by: " + extendedBy);
if (extendedBy != 0) {
if (yices_term_child(t, bvSize) == yices_false()) {
System.out.println("Zero-Extend");
} else {
System.out.println("Sign-extend");
}
}
System.out.println("--------END-------");
}
}
@Test
public void booleanParse() {
int test = yices_parse_term("false");
assertThat(yices_false()).isEqualTo(test);
int test2 = yices_parse_term("true");
assertThat(yices_true()).isEqualTo(test2);
}
@Test
public void bvSum() {
int type = yices_bv_type(5);
int bv1 = yices_named_variable(type, "x");
int bv2 = yices_named_variable(type, "y");
int add = yices_bvadd(bv1, bv2);
int constructor = yices_term_constructor(add);
assertThat(constructor).isEqualTo(YICES_BV_SUM);
}
@Test
public void bvMul() {
int type = yices_bv_type(5);
int bv2 = yices_named_variable(type, "x");
int mul = yices_bvmul(bv2, bv2);
System.out.println(yices_term_constructor(mul));
int[] component = yices_product_component(mul, 0);
System.out.println(component[0]);
System.out.println(component[1]);
System.out.println(yices_term_constructor(yices_bvpower(component[0], component[1])));
}
}
| 27,606 | 40.639517 | 97 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2NumeralFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_ARITH_CONST;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_add;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_arith_eq_atom;
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_arith_gt_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_arith_leq_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_arith_lt_atom;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_distinct;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_floor;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_int64;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_mul;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_neg;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_parse_float;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_parse_rational;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_sub;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_term_constructor;
import com.google.common.primitives.Ints;
import java.math.BigInteger;
import java.util.List;
import org.sosy_lab.java_smt.api.NumeralFormula;
import org.sosy_lab.java_smt.basicimpl.AbstractNumeralFormulaManager;
@SuppressWarnings("ClassTypeParameterName")
abstract class Yices2NumeralFormulaManager<
ParamFormulaType extends NumeralFormula, ResultFormulaType extends NumeralFormula>
extends AbstractNumeralFormulaManager<
Integer, Integer, Long, ParamFormulaType, ResultFormulaType, Integer> {
protected Yices2NumeralFormulaManager(
Yices2FormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
}
@Override
protected boolean isNumeral(Integer pVal) {
return yices_term_constructor(pVal) == YICES_ARITH_CONST;
}
@Override
public Integer makeNumberImpl(long pI) {
return yices_int64(pI);
}
@Override
public Integer makeNumberImpl(BigInteger pI) {
return makeNumberImpl(pI.toString());
}
@Override
public Integer makeNumberImpl(String pI) {
if (pI.contains("/")) {
return yices_parse_rational(pI);
} else {
return yices_parse_float(pI);
}
}
protected abstract int getNumeralType();
@Override
public Integer makeVariableImpl(String pI) {
return getFormulaCreator().makeVariable(getNumeralType(), pI);
}
@Override
public Integer negate(Integer pParam1) {
return yices_neg(pParam1);
}
@Override
public Integer add(Integer pParam1, Integer pParam2) {
return yices_add(pParam1, pParam2);
}
@Override
public Integer subtract(Integer pParam1, Integer pParam2) {
return yices_sub(pParam1, pParam2);
}
@Override
public Integer multiply(Integer pParam1, Integer pParam2) {
if (isNumeral(pParam1) || isNumeral(pParam2)) {
return yices_mul(pParam1, pParam2);
} else {
return super.multiply(pParam1, pParam2);
}
}
@Override
public Integer equal(Integer pParam1, Integer pParam2) {
return yices_arith_eq_atom(pParam1, pParam2);
}
@Override
public Integer distinctImpl(List<Integer> pNumbers) {
int[] numberTerms = Ints.toArray(pNumbers);
return yices_distinct(numberTerms.length, numberTerms);
}
@Override
public Integer greaterThan(Integer pParam1, Integer pParam2) {
return yices_arith_gt_atom(pParam1, pParam2);
}
@Override
public Integer greaterOrEquals(Integer pParam1, Integer pParam2) {
return yices_arith_geq_atom(pParam1, pParam2);
}
@Override
public Integer lessThan(Integer pParam1, Integer pParam2) {
return yices_arith_lt_atom(pParam1, pParam2);
}
@Override
public Integer lessOrEquals(Integer pParam1, Integer pParam2) {
return yices_arith_leq_atom(pParam1, pParam2);
}
@Override
protected Integer floor(Integer pNumber) {
return yices_floor(pNumber);
}
}
| 4,522 | 32.257353 | 90 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2QuantifiedFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_exists;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_forall;
import com.google.common.primitives.Ints;
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 Yices2QuantifiedFormulaManager
extends AbstractQuantifiedFormulaManager<Integer, Integer, Long, Integer> {
protected Yices2QuantifiedFormulaManager(
FormulaCreator<Integer, Integer, Long, Integer> pCreator) {
super(pCreator);
}
@Override
protected Integer eliminateQuantifiers(Integer pExtractInfo)
throws SolverException, InterruptedException {
// TODO Auto-generated method stub
throw new UnsupportedOperationException("Yices does not support eliminating Quantifiers.");
}
@Override
public Integer mkQuantifier(Quantifier pQ, List<Integer> pVars, Integer pBody) {
/*
* TODO Yices needs variables constructed using yices_new_variable(), but variables passed in
* pVars are constructed with yices_new uninterpreted_term(). Need to construct the correct
* variable type from the variables in pVars and map between them.
*/
if (pVars.isEmpty()) {
throw new IllegalArgumentException("Empty variable list for Quantifier.");
} else {
int[] terms = Ints.toArray(pVars);
if (pQ == Quantifier.FORALL) {
return yices_forall(terms.length, terms, pBody);
} else if (pQ == Quantifier.EXISTS) {
return yices_exists(terms.length, terms, pBody);
}
}
return null;
}
}
| 2,012 | 35.6 | 97 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2RationalFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_division;
import java.math.BigDecimal;
import org.sosy_lab.java_smt.api.NumeralFormula;
import org.sosy_lab.java_smt.api.NumeralFormula.RationalFormula;
import org.sosy_lab.java_smt.api.RationalFormulaManager;
public class Yices2RationalFormulaManager
extends Yices2NumeralFormulaManager<NumeralFormula, RationalFormula>
implements RationalFormulaManager {
protected Yices2RationalFormulaManager(
Yices2FormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
}
@Override
protected int getNumeralType() {
return getFormulaCreator().getRationalType();
}
@Override
protected Integer makeNumberImpl(double pNumber) {
return makeNumberImpl(Double.toString(pNumber));
}
@Override
protected Integer makeNumberImpl(BigDecimal pNumber) {
return makeNumberImpl(pNumber.toPlainString());
}
@Override
public Integer divide(Integer pParam1, Integer pParam2) {
if (isNumeral(pParam2)) {
return yices_division(pParam1, pParam2);
} else {
return super.divide(pParam1, pParam2);
}
}
}
| 1,489 | 28.215686 | 82 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2SolverContext.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_exit;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_get_major_version;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_get_patch_level;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_get_version;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_init;
import java.util.Set;
import java.util.function.Consumer;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
import org.sosy_lab.java_smt.api.BooleanFormulaManager;
import org.sosy_lab.java_smt.api.FormulaManager;
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.AbstractNumeralFormulaManager.NonLinearArithmetic;
import org.sosy_lab.java_smt.basicimpl.AbstractSolverContext;
public class Yices2SolverContext extends AbstractSolverContext {
private final Yices2FormulaCreator creator;
private final BooleanFormulaManager bfmgr;
private final ShutdownNotifier shutdownManager;
private static int numLoadedInstances = 0;
private boolean closed = false;
public Yices2SolverContext(
FormulaManager pFmgr,
Yices2FormulaCreator creator,
BooleanFormulaManager pBfmgr,
ShutdownNotifier pShutdownManager) {
super(pFmgr);
this.creator = creator;
bfmgr = pBfmgr;
shutdownManager = pShutdownManager;
}
public static Yices2SolverContext create(
NonLinearArithmetic pNonLinearArithmetic,
ShutdownNotifier pShutdownManager,
Consumer<String> pLoader) {
pLoader.accept("yices2j");
synchronized (Yices2SolverContext.class) {
if (numLoadedInstances == 0) {
// Avoid loading and initializing twice,
// because this would make all existing terms and types unavailable,
// which is bad behavior and a potential memory leak.
yices_init();
}
numLoadedInstances++;
}
Yices2FormulaCreator creator = new Yices2FormulaCreator();
Yices2UFManager functionTheory = new Yices2UFManager(creator);
Yices2BooleanFormulaManager booleanTheory = new Yices2BooleanFormulaManager(creator);
Yices2BitvectorFormulaManager bitvectorTheory =
new Yices2BitvectorFormulaManager(creator, booleanTheory);
Yices2IntegerFormulaManager integerTheory =
new Yices2IntegerFormulaManager(creator, pNonLinearArithmetic);
Yices2RationalFormulaManager rationalTheory =
new Yices2RationalFormulaManager(creator, pNonLinearArithmetic);
Yices2FormulaManager manager =
new Yices2FormulaManager(
creator, functionTheory, booleanTheory, integerTheory, rationalTheory, bitvectorTheory);
return new Yices2SolverContext(manager, creator, booleanTheory, pShutdownManager);
}
@Override
public String getVersion() {
return String.format(
"Yices %d.%d.%d", yices_get_version(), yices_get_major_version(), yices_get_patch_level());
}
@Override
public Solvers getSolverName() {
return Solvers.YICES2;
}
@Override
public synchronized void close() {
if (!closed) {
closed = true;
synchronized (Yices2SolverContext.class) {
numLoadedInstances--;
if (numLoadedInstances == 0) {
yices_exit();
}
}
}
}
@Override
protected ProverEnvironment newProverEnvironment0(Set<ProverOptions> pOptions) {
return new Yices2TheoremProver(creator, pOptions, bfmgr, shutdownManager);
}
@Override
protected InterpolatingProverEnvironment<?> newProverEnvironmentWithInterpolation0(
Set<ProverOptions> pSet) {
throw new UnsupportedOperationException("Yices does not support interpolation");
}
@Override
protected OptimizationProverEnvironment newOptimizationProverEnvironment0(
Set<ProverOptions> pSet) {
throw new UnsupportedOperationException("Yices does not support optimization");
}
@Override
protected boolean supportsAssumptionSolving() {
return true;
}
}
| 4,497 | 34.417323 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2TheoremProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.YICES_STATUS_UNSAT;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_assert_formula;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_check_sat;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_check_sat_with_assumptions;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_context_status;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_free_config;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_free_context;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_get_model;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_get_unsat_core;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_new_config;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_new_context;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_pop;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_push;
import static org.sosy_lab.java_smt.solvers.yices2.Yices2NativeApi.yices_set_config;
import com.google.common.base.Preconditions;
import com.google.common.primitives.Ints;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Deque;
import java.util.LinkedHashSet;
import java.util.List;
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.BooleanFormulaManager;
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;
/**
* Info about the option {@link ProverOptions#GENERATE_UNSAT_CORE}: Yices provides the unsat core
* only for additional formulae, not for already asserted ones. Thus, we have two possible
* solutions:
*
* <p>1) Avoid incremental solving and simply provide all formulae as additional ones. Currently
* implemented this way.
*
* <p>2) Add additional boolean symbols 'p', add a constraint 'p=f' for each asserted formula 'f',
* compute the unsat core over all 'p's, and match them back to their formula 'f'. This allows
* incremental solving, but is more complex to implement. Let's keep this idea is future work for
* optimization.
*/
class Yices2TheoremProver extends AbstractProverWithAllSat<Void> implements ProverEnvironment {
private static final int DEFAULT_PARAMS = 0; // use default setting in the solver
protected final Yices2FormulaCreator creator;
protected final long curEnv;
protected final long curCfg;
private final Deque<Set<Integer>> constraintStack = new ArrayDeque<>();
private int stackSizeToUnsat = Integer.MAX_VALUE;
protected Yices2TheoremProver(
Yices2FormulaCreator creator,
Set<ProverOptions> pOptions,
BooleanFormulaManager pBmgr,
ShutdownNotifier pShutdownNotifier) {
super(pOptions, pBmgr, pShutdownNotifier);
this.creator = creator;
curCfg = yices_new_config();
yices_set_config(curCfg, "solver-type", "dpllt");
yices_set_config(curCfg, "mode", "push-pop");
curEnv = yices_new_context(curCfg);
constraintStack.push(new LinkedHashSet<>()); // initial level
}
boolean isClosed() {
return closed;
}
@Override
public void pop() {
Preconditions.checkState(!closed);
if (constraintStack.size() <= stackSizeToUnsat) { // constraintStack and Yices stack have same
// level.
yices_pop(curEnv);
stackSizeToUnsat = Integer.MAX_VALUE; // Reset stackSizeToUnsat as this pop() will bring the
// stack into a pushable state if it was UNSAT before.
}
constraintStack.pop(); // Always pop constraintStack since it can get bigger than Yices stack.
}
@Override
public @Nullable Void addConstraint(BooleanFormula pConstraint) throws InterruptedException {
int constraint = creator.extractInfo(pConstraint);
if (!generateUnsatCores) { // unsat core does not work with incremental mode
yices_assert_formula(curEnv, constraint);
}
constraintStack.peek().add(constraint);
return null;
}
@Override
public void push() {
Preconditions.checkState(!closed);
if (constraintStack.size() <= stackSizeToUnsat
&& yices_context_status(curEnv) != YICES_STATUS_UNSAT) {
// Ensure that constraintStack and Yices stack are on the same level and Context is not UNSAT
// from assertions since last push.
yices_push(curEnv);
} else if (stackSizeToUnsat == Integer.MAX_VALUE) {
stackSizeToUnsat = constraintStack.size(); // if previous check fails and stackSizeToUnsat is
// not already set, set it to the current stack
// size before pushing.
}
constraintStack.push(new LinkedHashSet<>()); // Always push to ensure proper representation of
// push actions, even if Yices did not push.
}
@Override
public int size() {
Preconditions.checkState(!closed);
return constraintStack.size() - 1;
}
@Override
public boolean isUnsat() throws SolverException, InterruptedException {
Preconditions.checkState(!closed);
boolean unsat;
if (generateUnsatCores) { // unsat core does not work with incremental mode
int[] allConstraints = getAllConstraints();
unsat =
!yices_check_sat_with_assumptions(
curEnv, DEFAULT_PARAMS, allConstraints.length, allConstraints, shutdownNotifier);
} else {
unsat = !yices_check_sat(curEnv, DEFAULT_PARAMS, shutdownNotifier);
if (unsat && stackSizeToUnsat == Integer.MAX_VALUE) {
stackSizeToUnsat = constraintStack.size();
// If sat check is UNSAT and stackSizeToUnsat waS not already set,
// set to current constraintStack size.
}
}
return unsat;
}
private int[] getAllConstraints() {
Set<Integer> allConstraints = new LinkedHashSet<>();
constraintStack.forEach(allConstraints::addAll);
return Ints.toArray(allConstraints);
}
@Override
public boolean isUnsatWithAssumptions(Collection<BooleanFormula> pAssumptions)
throws SolverException, InterruptedException {
Preconditions.checkState(!closed);
// TODO handle BooleanFormulaCollection / check for literals
return !yices_check_sat_with_assumptions(
curEnv, DEFAULT_PARAMS, pAssumptions.size(), uncapsulate(pAssumptions), shutdownNotifier);
}
@SuppressWarnings("resource")
@Override
public Model getModel() throws SolverException {
Preconditions.checkState(!closed);
checkGenerateModels();
return new CachingModel(getEvaluatorWithoutChecks());
}
@Override
protected Yices2Model getEvaluatorWithoutChecks() {
return new Yices2Model(yices_get_model(curEnv, 1), this, creator);
}
private List<BooleanFormula> encapsulate(int[] terms) {
List<BooleanFormula> result = new ArrayList<>(terms.length);
for (int t : terms) {
result.add(creator.encapsulateBoolean(t));
}
return result;
}
private int[] uncapsulate(Collection<BooleanFormula> terms) {
int[] result = new int[terms.size()];
int i = 0;
for (BooleanFormula t : terms) {
result[i++] = creator.extractInfo(t);
}
return result;
}
@Override
public List<BooleanFormula> getUnsatCore() {
Preconditions.checkState(!closed);
checkGenerateUnsatCores();
return getUnsatCore0();
}
private List<BooleanFormula> getUnsatCore0() {
return encapsulate(yices_get_unsat_core(curEnv));
}
@Override
public Optional<List<BooleanFormula>> unsatCoreOverAssumptions(
Collection<BooleanFormula> pAssumptions) throws SolverException, InterruptedException {
Preconditions.checkState(!isClosed());
checkGenerateUnsatCoresOverAssumptions();
boolean sat = !isUnsatWithAssumptions(pAssumptions);
return sat ? Optional.empty() : Optional.of(getUnsatCore0());
}
@Override
public void close() {
if (!closed) {
yices_free_context(curEnv);
yices_free_config(curCfg);
constraintStack.clear();
closed = true;
}
}
}
| 8,746 | 37.030435 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/Yices2UFManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
package org.sosy_lab.java_smt.solvers.yices2;
import org.sosy_lab.java_smt.basicimpl.AbstractUFManager;
class Yices2UFManager extends AbstractUFManager<Integer, Integer, Integer, Long> {
protected Yices2UFManager(Yices2FormulaCreator pCreator) {
super(pCreator);
}
}
| 538 | 27.368421 | 82 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/yices2/package-info.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later
/** Interface to the SMT solver Yices2. */
@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.yices2;
| 573 | 37.266667 | 69 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/z3/Z3AbstractProver.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.z3;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.io.MoreFiles;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.microsoft.z3.Native;
import com.microsoft.z3.Z3Exception;
import com.microsoft.z3.enumerations.Z3_lbool;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
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.common.ShutdownNotifier.ShutdownRequestListener;
import org.sosy_lab.common.UniqueIdGenerator;
import org.sosy_lab.common.io.PathCounterTemplate;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.Model;
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;
abstract class Z3AbstractProver<T> extends AbstractProverWithAllSat<T> {
protected final Z3FormulaCreator creator;
protected final long z3context;
private final Z3FormulaManager mgr;
protected final long z3solver;
private final UniqueIdGenerator trackId = new UniqueIdGenerator();
private final @Nullable Map<String, BooleanFormula> storedConstraints;
private final @Nullable PathCounterTemplate logfile;
private final ShutdownRequestListener interruptListener;
Z3AbstractProver(
Z3FormulaCreator pCreator,
Z3FormulaManager pMgr,
Set<ProverOptions> pOptions,
ImmutableMap<String, Object> pSolverOptions,
@Nullable PathCounterTemplate pLogfile,
ShutdownNotifier pShutdownNotifier) {
super(pOptions, pMgr.getBooleanFormulaManager(), pShutdownNotifier);
creator = pCreator;
z3context = creator.getEnv();
z3solver = Native.mkSolver(z3context);
interruptListener = reason -> Native.solverInterrupt(z3context, z3solver);
shutdownNotifier.register(interruptListener);
storedConstraints =
pOptions.contains(ProverOptions.GENERATE_UNSAT_CORE) ? new HashMap<>() : null;
logfile = pLogfile;
mgr = pMgr;
Native.solverIncRef(z3context, z3solver);
long z3params = Native.mkParams(z3context);
Native.paramsIncRef(z3context, z3params);
for (Entry<String, Object> entry : pSolverOptions.entrySet()) {
addParameter(z3params, entry.getKey(), entry.getValue());
}
Native.solverSetParams(z3context, z3solver, z3params);
Native.paramsDecRef(z3context, z3params);
}
void addParameter(long z3params, String key, Object value) {
long keySymbol = Native.mkStringSymbol(z3context, key);
if (value instanceof Boolean) {
Native.paramsSetBool(z3context, z3params, keySymbol, (Boolean) value);
} else if (value instanceof Integer) {
Native.paramsSetUint(z3context, z3params, keySymbol, (Integer) value);
} else if (value instanceof Double) {
Native.paramsSetDouble(z3context, z3params, keySymbol, (Double) value);
} else if (value instanceof String) {
long valueSymbol = Native.mkStringSymbol(z3context, (String) value);
Native.paramsSetSymbol(z3context, z3params, keySymbol, valueSymbol);
} else {
throw new IllegalArgumentException(
String.format(
"unexpected type '%s' with value '%s' for parameter '%s'",
value.getClass(), value, key));
}
}
@Override
public boolean isUnsat() throws Z3SolverException, InterruptedException {
Preconditions.checkState(!closed);
logSolverStack();
int result;
try {
result = Native.solverCheck(z3context, z3solver);
} catch (Z3Exception e) {
throw creator.handleZ3Exception(e);
}
undefinedStatusToException(result);
return result == Z3_lbool.Z3_L_FALSE.toInt();
}
/** dump the current solver stack into a new SMTLIB file. */
private void logSolverStack() throws Z3SolverException {
if (logfile != null) { // if logging is not disabled
try {
// write stack content to logfile
Path filename = logfile.getFreshPath();
MoreFiles.createParentDirectories(filename);
Files.writeString(filename, Native.solverToString(z3context, z3solver) + "(check-sat)\n");
} catch (IOException e) {
throw new Z3SolverException("Cannot write Z3 log file: " + e.getMessage());
}
}
}
@Override
public boolean isUnsatWithAssumptions(Collection<BooleanFormula> assumptions)
throws Z3SolverException, InterruptedException {
Preconditions.checkState(!closed);
int result;
try {
result =
Native.solverCheckAssumptions(
z3context,
z3solver,
assumptions.size(),
assumptions.stream().mapToLong(creator::extractInfo).toArray());
} catch (Z3Exception e) {
throw creator.handleZ3Exception(e);
}
undefinedStatusToException(result);
return result == Z3_lbool.Z3_L_FALSE.toInt();
}
protected final void undefinedStatusToException(int solverStatus)
throws Z3SolverException, InterruptedException {
if (solverStatus == Z3_lbool.Z3_L_UNDEF.toInt()) {
creator.shutdownNotifier.shutdownIfNecessary();
final String reason = Native.solverGetReasonUnknown(z3context, z3solver);
switch (reason) {
case "canceled": // see Z3: src/tactic/tactic.cpp
case "interrupted": // see Z3: src/solver/check_sat_result.cpp
case "interrupted from keyboard": // see Z3: src/solver/check_sat_result.cpp
throw new InterruptedException(reason);
default:
throw new Z3SolverException("Solver returned 'unknown' status, reason: " + reason);
}
}
}
@SuppressWarnings("resource")
@Override
public Model getModel() {
Preconditions.checkState(!closed);
checkGenerateModels();
return new CachingModel(getEvaluatorWithoutChecks());
}
@Override
protected Z3Model getEvaluatorWithoutChecks() {
return new Z3Model(this, z3context, getZ3Model(), creator);
}
protected long getZ3Model() {
return Native.solverGetModel(z3context, z3solver);
}
@CanIgnoreReturnValue
protected long addConstraint0(BooleanFormula f) throws InterruptedException {
Preconditions.checkState(!closed);
long e = creator.extractInfo(f);
Native.incRef(z3context, e);
try {
if (storedConstraints != null) { // Unsat core generation is on.
String varName = String.format("Z3_UNSAT_CORE_%d", trackId.getFreshId());
BooleanFormula t = mgr.getBooleanFormulaManager().makeVariable(varName);
Native.solverAssertAndTrack(z3context, z3solver, e, creator.extractInfo(t));
storedConstraints.put(varName, f);
Native.decRef(z3context, e);
} else {
assertContraint(e);
}
} catch (Z3Exception exception) {
throw creator.handleZ3Exception(exception);
}
Native.decRef(z3context, e);
return e;
}
@Override
public void push() throws InterruptedException {
Preconditions.checkState(!closed);
try {
Native.solverPush(z3context, z3solver);
} catch (Z3Exception exception) {
throw creator.handleZ3Exception(exception);
}
}
@Override
public void pop() {
Preconditions.checkState(!closed);
Preconditions.checkState(Native.solverGetNumScopes(z3context, z3solver) >= 1);
Native.solverPop(z3context, z3solver, 1);
}
@Override
public int size() {
Preconditions.checkState(!closed);
return Native.solverGetNumScopes(z3context, z3solver);
}
@Override
public List<BooleanFormula> getUnsatCore() {
Preconditions.checkState(!closed);
checkGenerateUnsatCores();
if (storedConstraints == null) {
throw new UnsupportedOperationException(
"Option to generate the UNSAT core wasn't enabled when creating the prover environment.");
}
List<BooleanFormula> constraints = new ArrayList<>();
long unsatCore = Native.solverGetUnsatCore(z3context, z3solver);
Native.astVectorIncRef(z3context, unsatCore);
for (int i = 0; i < Native.astVectorSize(z3context, unsatCore); i++) {
long ast = Native.astVectorGet(z3context, unsatCore, i);
Native.incRef(z3context, ast);
String varName = Native.astToString(z3context, ast);
Native.decRef(z3context, ast);
constraints.add(storedConstraints.get(varName));
}
Native.astVectorDecRef(z3context, unsatCore);
return constraints;
}
@Override
public Optional<List<BooleanFormula>> unsatCoreOverAssumptions(
Collection<BooleanFormula> assumptions) throws SolverException, InterruptedException {
checkGenerateUnsatCoresOverAssumptions();
if (!isUnsatWithAssumptions(assumptions)) {
return Optional.empty();
}
List<BooleanFormula> core = new ArrayList<>();
long unsatCore = Native.solverGetUnsatCore(z3context, z3solver);
Native.astVectorIncRef(z3context, unsatCore);
for (int i = 0; i < Native.astVectorSize(z3context, unsatCore); i++) {
long ast = Native.astVectorGet(z3context, unsatCore, i);
core.add(creator.encapsulateBoolean(ast));
}
Native.astVectorDecRef(z3context, unsatCore);
return Optional.of(core);
}
@Override
public ImmutableMap<String, String> getStatistics() {
// Z3 sigsevs if you try to get statistics for closed environments
Preconditions.checkState(!closed);
ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
Set<String> seenKeys = new HashSet<>();
final long stats = Native.solverGetStatistics(z3context, z3solver);
for (int i = 0; i < Native.statsSize(z3context, stats); i++) {
String key = getUnusedKey(seenKeys, Native.statsGetKey(z3context, stats, i));
if (Native.statsIsUint(z3context, stats, i)) {
builder.put(key, Integer.toString(Native.statsGetUintValue(z3context, stats, i)));
} else if (Native.statsIsDouble(z3context, stats, i)) {
builder.put(key, Double.toString(Native.statsGetDoubleValue(z3context, stats, i)));
} else {
throw new IllegalStateException(
String.format(
"Unknown data entry value for key %s at position %d in statistics '%s'",
key, i, Native.statsToString(z3context, stats)));
}
}
return builder.buildOrThrow();
}
/**
* In some cases, Z3 uses the same statistics key twice. In those cases, we append an index to the
* second usage.
*/
private String getUnusedKey(Set<String> seenKeys, final String originalKey) {
if (seenKeys.add(originalKey)) {
return originalKey;
}
String key;
int index = 0;
do {
index++;
key = originalKey + " (" + index + ")";
} while (!seenKeys.add(key));
return key;
}
@Override
public void close() {
if (!closed) {
Preconditions.checkArgument(
Native.solverGetNumScopes(z3context, z3solver) >= 0,
"a negative number of scopes is not allowed");
Native.solverReset(z3context, z3solver); // remove all assertions from the solver
Native.solverDecRef(z3context, z3solver);
shutdownNotifier.unregister(interruptListener);
closed = true;
}
}
@Override
public String toString() {
if (closed) {
return "Closed Z3Solver";
}
return Native.solverToString(z3context, z3solver);
}
@Override
public <R> R allSat(AllSatCallback<R> callback, List<BooleanFormula> important)
throws InterruptedException, SolverException {
try {
return super.allSat(callback, important);
} catch (Z3Exception e) {
throw creator.handleZ3Exception(e);
}
}
protected void assertContraint(long negatedModel) {
Native.solverAssert(z3context, z3solver, negatedModel);
}
}
| 12,328 | 33.632022 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/z3/Z3ArrayFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.z3;
import com.microsoft.z3.Native;
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;
class Z3ArrayFormulaManager extends AbstractArrayFormulaManager<Long, Long, Long, Long> {
private final long z3context;
Z3ArrayFormulaManager(Z3FormulaCreator creator) {
super(creator);
this.z3context = creator.getEnv();
}
@Override
protected Long select(Long pArray, Long pIndex) {
return Native.mkSelect(z3context, pArray, pIndex);
}
@Override
protected Long store(Long pArray, Long pIndex, Long pValue) {
return Native.mkStore(z3context, pArray, pIndex, pValue);
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TI extends Formula, TE extends Formula> Long internalMakeArray(
String pName, FormulaType<TI> pIndexType, FormulaType<TE> pElementType) {
final ArrayFormulaType<TI, TE> arrayFormulaType =
FormulaType.getArrayType(pIndexType, pElementType);
final Long z3ArrayType = toSolverType(arrayFormulaType);
return getFormulaCreator().makeVariable(z3ArrayType, pName);
}
@Override
protected Long equivalence(Long pArray1, Long pArray2) {
return Native.mkEq(z3context, pArray1, pArray2);
}
}
| 1,635 | 29.867925 | 89 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/z3/Z3BitvectorFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.z3;
import com.google.common.primitives.Longs;
import com.microsoft.z3.Native;
import java.math.BigInteger;
import java.util.List;
import org.sosy_lab.java_smt.basicimpl.AbstractBitvectorFormulaManager;
class Z3BitvectorFormulaManager extends AbstractBitvectorFormulaManager<Long, Long, Long, Long> {
private final long z3context;
Z3BitvectorFormulaManager(Z3FormulaCreator creator, Z3BooleanFormulaManager pBmgr) {
super(creator, pBmgr);
this.z3context = creator.getEnv();
}
@Override
public Long concat(Long pFirst, Long pSecond) {
return Native.mkConcat(z3context, pFirst, pSecond);
}
@Override
public Long extract(Long pNumber, int pMsb, int pLsb) {
return Native.mkExtract(z3context, pMsb, pLsb, pNumber);
}
@Override
public Long extend(Long pNumber, int pExtensionBits, boolean pSigned) {
if (pSigned) {
return Native.mkSignExt(z3context, pExtensionBits, pNumber);
} else {
return Native.mkZeroExt(z3context, pExtensionBits, pNumber);
}
}
@Override
protected Long makeBitvectorImpl(int pLength, BigInteger pI) {
pI = transformValueToRange(pLength, pI);
long sort = Native.mkBvSort(z3context, pLength);
return Native.mkNumeral(z3context, pI.toString(), sort);
}
@Override
protected Long makeBitvectorImpl(int pLength, Long pNumeralFormula) {
return Native.mkInt2bv(z3context, pLength, pNumeralFormula);
}
@Override
protected Long toIntegerFormulaImpl(Long pBVFormula, boolean pSigned) {
return Native.mkBv2int(z3context, pBVFormula, pSigned);
}
@Override
public Long makeVariableImpl(int length, String varName) {
long type = getFormulaCreator().getBitvectorType(length);
return getFormulaCreator().makeVariable(type, varName);
}
/**
* Return a term representing the (arithmetic if signed is true) right shift of number by toShift.
*/
@Override
public Long shiftRight(Long number, Long toShift, boolean signed) {
if (signed) {
return Native.mkBvashr(z3context, number, toShift);
} else {
return Native.mkBvlshr(z3context, number, toShift);
}
}
@Override
public Long shiftLeft(Long number, Long toShift) {
return Native.mkBvshl(z3context, number, toShift);
}
@Override
public Long not(Long pBits) {
return Native.mkBvnot(z3context, pBits);
}
@Override
public Long and(Long pBits1, Long pBits2) {
return Native.mkBvand(z3context, pBits1, pBits2);
}
@Override
public Long or(Long pBits1, Long pBits2) {
return Native.mkBvor(z3context, pBits1, pBits2);
}
@Override
public Long xor(Long pBits1, Long pBits2) {
return Native.mkBvxor(z3context, pBits1, pBits2);
}
@Override
public Long negate(Long pNumber) {
return Native.mkBvneg(z3context, pNumber);
}
@Override
public Long add(Long pNumber1, Long pNumber2) {
return Native.mkBvadd(z3context, pNumber1, pNumber2);
}
@Override
public Long subtract(Long pNumber1, Long pNumber2) {
return Native.mkBvsub(z3context, pNumber1, pNumber2);
}
@Override
public Long divide(Long pNumber1, Long pNumber2, boolean signed) {
if (signed) {
return Native.mkBvsdiv(z3context, pNumber1, pNumber2);
} else {
return Native.mkBvudiv(z3context, pNumber1, pNumber2);
}
}
@Override
public Long modulo(Long pNumber1, Long pNumber2, boolean signed) {
if (signed) {
return Native.mkBvsrem(z3context, pNumber1, pNumber2);
} else {
return Native.mkBvurem(z3context, pNumber1, pNumber2);
}
}
@Override
public Long multiply(Long pNumber1, Long pNumber2) {
return Native.mkBvmul(z3context, pNumber1, pNumber2);
}
@Override
public Long equal(Long pNumber1, Long pNumber2) {
return Native.mkEq(z3context, pNumber1, pNumber2);
}
@Override
public Long lessThan(Long pNumber1, Long pNumber2, boolean signed) {
if (signed) {
return Native.mkBvslt(z3context, pNumber1, pNumber2);
} else {
return Native.mkBvult(z3context, pNumber1, pNumber2);
}
}
@Override
public Long lessOrEquals(Long pNumber1, Long pNumber2, boolean signed) {
if (signed) {
return Native.mkBvsle(z3context, pNumber1, pNumber2);
} else {
return Native.mkBvule(z3context, pNumber1, pNumber2);
}
}
@Override
public Long greaterThan(Long pNumber1, Long pNumber2, boolean signed) {
return lessThan(pNumber2, pNumber1, signed);
}
@Override
public Long greaterOrEquals(Long pNumber1, Long pNumber2, boolean signed) {
return lessOrEquals(pNumber2, pNumber1, signed);
}
@Override
protected Long distinctImpl(List<Long> pBits) {
return Native.mkDistinct(z3context, pBits.size(), Longs.toArray(pBits));
}
}
| 4,989 | 26.569061 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/z3/Z3BooleanFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.z3;
import static org.sosy_lab.java_smt.solvers.z3.Z3FormulaCreator.isOP;
import com.google.common.collect.Iterables;
import com.google.common.primitives.Longs;
import com.microsoft.z3.Native;
import com.microsoft.z3.enumerations.Z3_decl_kind;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.Set;
import org.sosy_lab.java_smt.basicimpl.AbstractBooleanFormulaManager;
class Z3BooleanFormulaManager extends AbstractBooleanFormulaManager<Long, Long, Long, Long> {
private final long z3context;
private final Long z3true;
private final Long z3false;
Z3BooleanFormulaManager(Z3FormulaCreator creator) {
super(creator);
z3context = creator.getEnv();
z3true = Native.mkTrue(z3context);
Native.incRef(z3context, z3true);
z3false = Native.mkFalse(z3context);
Native.incRef(z3context, z3false);
}
@Override
protected Long makeVariableImpl(String varName) {
long type = getFormulaCreator().getBoolType();
return getFormulaCreator().makeVariable(type, varName);
}
@Override
protected Long makeBooleanImpl(boolean pValue) {
return pValue ? z3true : z3false;
}
@Override
protected Long not(Long pParam) {
if (isTrue(pParam)) {
return z3false;
} else if (isFalse(pParam)) {
return z3true;
} else if (isOP(z3context, pParam, Z3_decl_kind.Z3_OP_NOT)) {
return Native.getAppArg(z3context, pParam, 0);
}
return Native.mkNot(z3context, pParam);
}
@Override
protected Long and(Long pParam1, Long pParam2) {
if (isTrue(pParam1)) {
return pParam2;
} else if (isTrue(pParam2)) {
return pParam1;
} else if (isFalse(pParam1)) {
return z3false;
} else if (isFalse(pParam2)) {
return z3false;
} else if (Native.isEqAst(z3context, pParam1, pParam2)) {
return pParam1;
}
return Native.mkAnd(z3context, 2, new long[] {pParam1, pParam2});
}
@Override
protected Long or(Long pParam1, Long pParam2) {
if (isTrue(pParam1)) {
return z3true;
} else if (isTrue(pParam2)) {
return z3true;
} else if (isFalse(pParam1)) {
return pParam2;
} else if (isFalse(pParam2)) {
return pParam1;
} else if (Native.isEqAst(z3context, pParam1, pParam2)) {
return pParam1;
}
return Native.mkOr(z3context, 2, new long[] {pParam1, pParam2});
}
@Override
protected Long orImpl(Collection<Long> params) {
// Z3 does not do any simplifications,
// so we filter "true", short-circuit on "false", and filter out (simple) redundancies.
final Set<Long> operands = new LinkedHashSet<>();
for (final Long operand : params) {
if (isTrue(operand)) {
return z3true;
}
if (!isFalse(operand)) {
operands.add(operand);
}
}
switch (operands.size()) {
case 0:
return z3false;
case 1:
return Iterables.getOnlyElement(operands);
default:
return Native.mkOr(z3context, operands.size(), Longs.toArray(operands));
}
}
@Override
protected Long andImpl(Collection<Long> params) {
// Z3 does not do any simplifications,
// so we filter "true", short-circuit on "false", and filter out (simple) redundancies.
final Set<Long> operands = new LinkedHashSet<>();
for (final Long operand : params) {
if (isFalse(operand)) {
return z3false;
}
if (!isTrue(operand)) {
operands.add(operand);
}
}
switch (operands.size()) {
case 0:
return z3true;
case 1:
return Iterables.getOnlyElement(operands);
default:
return Native.mkAnd(z3context, operands.size(), Longs.toArray(operands));
}
}
@Override
protected Long xor(Long pParam1, Long pParam2) {
return Native.mkXor(z3context, pParam1, pParam2);
}
@Override
protected Long equivalence(Long pBits1, Long pBits2) {
return Native.mkEq(z3context, pBits1, pBits2);
}
@Override
protected Long implication(Long pBits1, Long pBits2) {
return Native.mkImplies(z3context, pBits1, pBits2);
}
@Override
protected boolean isTrue(Long pParam) {
return isOP(z3context, pParam, Z3_decl_kind.Z3_OP_TRUE);
}
@Override
protected boolean isFalse(Long pParam) {
return isOP(z3context, pParam, Z3_decl_kind.Z3_OP_FALSE);
}
@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 Native.mkIte(z3context, pCond, pF1, pF2);
}
}
| 5,017 | 27.03352 | 93 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/z3/Z3EnumerationFormulaManager.java | // 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 <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.z3;
import com.google.common.collect.ImmutableMap;
import com.microsoft.z3.Native;
import org.sosy_lab.java_smt.api.FormulaType.EnumerationFormulaType;
import org.sosy_lab.java_smt.basicimpl.AbstractEnumerationFormulaManager;
class Z3EnumerationFormulaManager
extends AbstractEnumerationFormulaManager<Long, Long, Long, Long> {
private final long z3context;
Z3EnumerationFormulaManager(Z3FormulaCreator creator) {
super(creator);
this.z3context = creator.getEnv();
}
@Override
protected EnumType declareEnumeration0(EnumerationFormulaType pType) {
long symbol = Native.mkStringSymbol(z3context, pType.getName());
String[] elements = pType.getElements().toArray(new String[] {});
long[] elementSymbols = new long[elements.length];
for (int i = 0; i < elements.length; i++) {
elementSymbols[i] = Native.mkStringSymbol(z3context, elements[i]);
}
long[] constants = new long[pType.getElements().size()];
long[] predicates = new long[pType.getElements().size()]; // unused later
long enumType =
Native.mkEnumerationSort(
z3context, symbol, elements.length, elementSymbols, constants, predicates);
Native.incRef(z3context, enumType);
// we store the constants for later access
ImmutableMap.Builder<String, Long> constantsMapping = ImmutableMap.builder();
for (int i = 0; i < elements.length; i++) {
long constantApp = Native.mkApp(z3context, constants[i], 0, null);
Native.incRef(z3context, constantApp);
constantsMapping.put(elements[i], constantApp);
}
return new EnumType(pType, enumType, constantsMapping.buildOrThrow());
}
@Override
protected Long equivalenceImpl(Long pF1, Long pF2) {
return Native.mkEq(z3context, pF1, pF2);
}
}
| 2,052 | 33.79661 | 87 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/z3/Z3FloatingPointFormulaManager.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.z3;
import com.google.common.collect.ImmutableList;
import com.microsoft.z3.Native;
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;
class Z3FloatingPointFormulaManager
extends AbstractFloatingPointFormulaManager<Long, Long, Long, Long> {
private static final FloatingPointType highPrec = FormulaType.getFloatingPointType(15, 112);
private final long z3context;
private final long roundingMode;
Z3FloatingPointFormulaManager(
Z3FormulaCreator creator, FloatingPointRoundingMode pFloatingPointRoundingMode) {
super(creator);
z3context = creator.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 = Native.mkFpaRoundNearestTiesToEven(z3context);
break;
case NEAREST_TIES_AWAY:
out = Native.mkFpaRoundNearestTiesToAway(z3context);
break;
case TOWARD_POSITIVE:
out = Native.mkFpaRoundTowardPositive(z3context);
break;
case TOWARD_NEGATIVE:
out = Native.mkFpaRoundTowardNegative(z3context);
break;
case TOWARD_ZERO:
out = Native.mkFpaRoundTowardZero(z3context);
break;
default:
throw new AssertionError("Unexpected value");
}
Native.incRef(z3context, out);
return out;
}
private long mkFpaSort(FloatingPointType pType) {
return getFormulaCreator().getFloatingPointType(pType);
}
@Override
protected Long makeNumberImpl(double pN, FloatingPointType pType, Long pRoundingMode) {
return makeNumberImpl(Double.toString(pN), pType, pRoundingMode);
}
@Override
protected Long makeNumberAndRound(String pN, FloatingPointType pType, Long pRoundingMode) {
// Z3 does not allow specifying a rounding mode for numerals,
// so we create it first with a high precision and then round it down explicitly.
if (pType.getExponentSize() <= highPrec.getExponentSize()
|| pType.getMantissaSize() <= highPrec.getMantissaSize()) {
long highPrecNumber = Native.mkNumeral(z3context, pN, mkFpaSort(highPrec));
Native.incRef(z3context, highPrecNumber);
long smallPrecNumber =
castToImpl(highPrecNumber, /* irrelevant: */ true, pType, pRoundingMode);
Native.incRef(z3context, smallPrecNumber);
long result = Native.simplify(z3context, smallPrecNumber);
Native.decRef(z3context, highPrecNumber);
Native.decRef(z3context, smallPrecNumber);
return result;
}
return Native.mkNumeral(z3context, pN, mkFpaSort(pType));
}
@Override
protected Long makeVariableImpl(String var, FloatingPointType pType) {
return getFormulaCreator().makeVariable(mkFpaSort(pType), var);
}
@Override
protected Long makePlusInfinityImpl(FloatingPointType pType) {
return Native.mkFpaInf(z3context, mkFpaSort(pType), false);
}
@Override
protected Long makeMinusInfinityImpl(FloatingPointType pType) {
return Native.mkFpaInf(z3context, mkFpaSort(pType), true);
}
@Override
protected Long makeNaNImpl(FloatingPointType pType) {
return Native.mkFpaNan(z3context, mkFpaSort(pType));
}
@Override
protected Long castToImpl(
Long pNumber, boolean pSigned, FormulaType<?> pTargetType, Long pRoundingMode) {
if (pTargetType.isFloatingPointType()) {
FormulaType.FloatingPointType targetType = (FormulaType.FloatingPointType) pTargetType;
return Native.mkFpaToFpFloat(z3context, pRoundingMode, pNumber, mkFpaSort(targetType));
} else if (pTargetType.isBitvectorType()) {
FormulaType.BitvectorType targetType = (FormulaType.BitvectorType) pTargetType;
if (pSigned) {
return Native.mkFpaToSbv(z3context, pRoundingMode, pNumber, targetType.getSize());
} else {
return Native.mkFpaToUbv(z3context, pRoundingMode, pNumber, targetType.getSize());
}
} else if (pTargetType.isRationalType()) {
return Native.mkFpaToReal(z3context, pNumber);
} else {
return genericCast(pNumber, pTargetType);
}
}
@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 Native.mkFpaToFpSigned(z3context, pRoundingMode, pNumber, mkFpaSort(pTargetType));
} else {
return Native.mkFpaToFpUnsigned(z3context, pRoundingMode, pNumber, mkFpaSort(pTargetType));
}
} else if (formulaType.isRationalType()) {
return Native.mkFpaToFpReal(z3context, pRoundingMode, pNumber, mkFpaSort(pTargetType));
} else {
return genericCast(pNumber, pTargetType);
}
}
private Long genericCast(Long pNumber, FormulaType<?> pTargetType) {
FormulaType<?> argType = getFormulaCreator().getFormulaType(pNumber);
long castFuncDecl =
getFormulaCreator()
.declareUFImpl(
"__cast_" + argType + "_to_" + pTargetType,
toSolverType(pTargetType),
ImmutableList.of(toSolverType(argType)));
return Native.mkApp(z3context, castFuncDecl, 1, new long[] {pNumber});
}
@Override
protected Long fromIeeeBitvectorImpl(Long pNumber, FloatingPointType pTargetType) {
return Native.mkFpaToFpBv(z3context, pNumber, mkFpaSort(pTargetType));
}
@Override
protected Long toIeeeBitvectorImpl(Long pNumber) {
return Native.mkFpaToIeeeBv(z3context, pNumber);
}
@Override
protected Long negate(Long pNumber) {
return Native.mkFpaNeg(z3context, pNumber);
}
@Override
protected Long abs(Long pNumber) {
return Native.mkFpaAbs(z3context, pNumber);
}
@Override
protected Long max(Long pNumber1, Long pNumber2) {
return Native.mkFpaMax(z3context, pNumber1, pNumber2);
}
@Override
protected Long min(Long pNumber1, Long pNumber2) {
return Native.mkFpaMin(z3context, pNumber1, pNumber2);
}
@Override
protected Long sqrt(Long pNumber, Long pRoundingMode) {
return Native.mkFpaSqrt(z3context, pRoundingMode, pNumber);
}
@Override
protected Long add(Long pNumber1, Long pNumber2, Long pRoundingMode) {
return Native.mkFpaAdd(z3context, pRoundingMode, pNumber1, pNumber2);
}
@Override
protected Long subtract(Long pNumber1, Long pNumber2, Long pRoundingMode) {
return Native.mkFpaSub(z3context, pRoundingMode, pNumber1, pNumber2);
}
@Override
protected Long multiply(Long pNumber1, Long pNumber2, Long pRoundingMode) {
return Native.mkFpaMul(z3context, pRoundingMode, pNumber1, pNumber2);
}
@Override
protected Long divide(Long pNumber1, Long pNumber2, Long pRoundingMode) {
return Native.mkFpaDiv(z3context, pRoundingMode, pNumber1, pNumber2);
}
@Override
protected Long assignment(Long pNumber1, Long pNumber2) {
return Native.mkEq(z3context, pNumber1, pNumber2);
}
@Override
protected Long equalWithFPSemantics(Long pNumber1, Long pNumber2) {
return Native.mkFpaEq(z3context, pNumber1, pNumber2);
}
@Override
protected Long greaterThan(Long pNumber1, Long pNumber2) {
return Native.mkFpaGt(z3context, pNumber1, pNumber2);
}
@Override
protected Long greaterOrEquals(Long pNumber1, Long pNumber2) {
return Native.mkFpaGeq(z3context, pNumber1, pNumber2);
}
@Override
protected Long lessThan(Long pNumber1, Long pNumber2) {
return Native.mkFpaLt(z3context, pNumber1, pNumber2);
}
@Override
protected Long lessOrEquals(Long pNumber1, Long pNumber2) {
return Native.mkFpaLeq(z3context, pNumber1, pNumber2);
}
@Override
protected Long isNaN(Long pParam) {
return Native.mkFpaIsNan(z3context, pParam);
}
@Override
protected Long isInfinity(Long pParam) {
return Native.mkFpaIsInfinite(z3context, pParam);
}
@Override
protected Long isZero(Long pParam) {
return Native.mkFpaIsZero(z3context, pParam);
}
@Override
protected Long isSubnormal(Long pParam) {
return Native.mkFpaIsSubnormal(z3context, pParam);
}
@Override
protected Long isNormal(Long pParam) {
return Native.mkFpaIsNormal(z3context, pParam);
}
@Override
protected Long isNegative(Long pParam) {
return Native.mkFpaIsNegative(z3context, pParam);
}
@Override
protected Long round(Long pFormula, FloatingPointRoundingMode pRoundingMode) {
return Native.mkFpaRoundToIntegral(z3context, getRoundingModeImpl(pRoundingMode), pFormula);
}
}
| 9,286 | 31.134948 | 99 | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.