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/delegate/logging/LoggingSolverContext.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.delegate.logging;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.collect.ImmutableMap;
import org.sosy_lab.common.log.LogManager;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
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.api.SolverContext;
/** {@link SolverContext} that wraps all prover environments in their logging versions. */
public final class LoggingSolverContext implements SolverContext {
private final LogManager logger;
private final SolverContext delegate;
public LoggingSolverContext(LogManager pLogger, SolverContext pDelegate) {
logger = checkNotNull(pLogger);
delegate = checkNotNull(pDelegate);
}
@Override
public FormulaManager getFormulaManager() {
return delegate.getFormulaManager();
}
@SuppressWarnings("resource")
@Override
public ProverEnvironment newProverEnvironment(ProverOptions... pOptions) {
return new LoggingProverEnvironment(logger, delegate.newProverEnvironment(pOptions));
}
@SuppressWarnings("resource")
@Override
public InterpolatingProverEnvironment<?> newProverEnvironmentWithInterpolation(
ProverOptions... options) {
return new LoggingInterpolatingProverEnvironment<>(
logger, delegate.newProverEnvironmentWithInterpolation(options));
}
@SuppressWarnings("resource")
@Override
public OptimizationProverEnvironment newOptimizationProverEnvironment(ProverOptions... options) {
return new LoggingOptimizationProverEnvironment(
logger, delegate.newOptimizationProverEnvironment(options));
}
@Override
public String getVersion() {
return delegate.getVersion();
}
@Override
public Solvers getSolverName() {
return delegate.getSolverName();
}
@Override
public ImmutableMap<String, String> getStatistics() {
return delegate.getStatistics();
}
@Override
public void close() {
delegate.close();
}
}
| 2,407 | 29.481013 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/logging/PackageSanityTest.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.delegate.logging;
import com.google.common.testing.AbstractPackageSanityTests;
public class PackageSanityTest extends AbstractPackageSanityTests {}
| 420 | 29.071429 | 69 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/logging/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
/** Wraps the proving environment with loggers. */
@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.delegate.logging;
| 563 | 36.6 | 69 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/SolverStatistics.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.delegate.statistics;
import com.google.common.collect.ImmutableMap;
import java.util.concurrent.atomic.AtomicInteger;
import org.sosy_lab.common.time.TimeSpan;
public class SolverStatistics {
// prover operations
final AtomicInteger provers = new AtomicInteger();
final AtomicInteger pop = new AtomicInteger();
final AtomicInteger push = new AtomicInteger();
final AtomicInteger constraint = new AtomicInteger();
final AtomicInteger model = new AtomicInteger();
final AtomicInteger unsatCore = new AtomicInteger();
final TimerPool unsat = new TimerPool();
final TimerPool allSat = new TimerPool();
final TimerPool interpolation = new TimerPool();
// manager operations
final AtomicInteger visits = new AtomicInteger();
final AtomicInteger booleanOperations = new AtomicInteger();
final AtomicInteger numericOperations = new AtomicInteger();
final AtomicInteger arrayOperations = new AtomicInteger();
final AtomicInteger slOperations = new AtomicInteger();
final AtomicInteger ufOperations = new AtomicInteger();
final AtomicInteger quantifierOperations = new AtomicInteger();
final AtomicInteger bvOperations = new AtomicInteger();
final AtomicInteger fpOperations = new AtomicInteger();
final AtomicInteger typeOperations = new AtomicInteger();
final AtomicInteger stringOperations = new AtomicInteger();
final AtomicInteger enumerationDeclarations = new AtomicInteger();
final AtomicInteger enumerationOperations = new AtomicInteger();
// model operations
final AtomicInteger modelEvaluations = new AtomicInteger();
final AtomicInteger modelListings = new AtomicInteger();
SolverStatistics() {}
// visible access methods
public int getNumberOfProverEnvironments() {
return provers.get();
}
public int getNumberOfPopQueries() {
return pop.get();
}
public int getNumberOfPushQueries() {
return push.get();
}
public int getNumberOfAddConstraintQueries() {
return constraint.get();
}
public int getNumberOfModelQueries() {
return model.get();
}
public int getNumberOfUnsatCoreQueries() {
return unsatCore.get();
}
public int getNumberOfIsUnsatQueries() {
return unsat.getNumberOfIntervals();
}
public TimeSpan getSumTimeOfIsUnsatQueries() {
return unsat.getSumTime();
}
public TimeSpan getMaxTimeOfIsUnsatQueries() {
return unsat.getMaxTime();
}
public int getNumberOfAllSatQueries() {
return allSat.getNumberOfIntervals();
}
public TimeSpan getSumTimeOfAllSatQueries() {
return allSat.getSumTime();
}
public TimeSpan getMaxTimeOfAllSatQueries() {
return allSat.getMaxTime();
}
public int getNumberOfInterpolationQueries() {
return interpolation.getNumberOfIntervals();
}
public TimeSpan getSumTimeOfInterpolationQueries() {
return interpolation.getSumTime();
}
public TimeSpan getMaxTimeOfInterpolationQueries() {
return interpolation.getMaxTime();
}
public int getNumberOfBooleanOperations() {
return booleanOperations.get();
}
public int getNumberOfVisits() {
return visits.get();
}
public int getNumberOfNumericOperations() {
return numericOperations.get();
}
public int getNumberOfArrayOperations() {
return arrayOperations.get();
}
public int getNumberOfSLOperations() {
return slOperations.get();
}
public int getNumberOfUFOperations() {
return ufOperations.get();
}
public int getNumberOfQuantifierOperations() {
return quantifierOperations.get();
}
public int getNumberOfBVOperations() {
return bvOperations.get();
}
public int getNumberOfFPOperations() {
return fpOperations.get();
}
public int getNumberOfStringOperations() {
return stringOperations.get();
}
public int getNumberOfModelEvaluationQueries() {
return modelEvaluations.get();
}
public int getNumberOfModelListings() {
return modelListings.get();
}
public ImmutableMap<String, Object> asMap() {
return ImmutableMap.<String, Object>builder()
.put("number of prover environments", getNumberOfProverEnvironments())
.put("number of pop queries", getNumberOfPopQueries())
.put("number of push queries", getNumberOfPushQueries())
.put("number of addConstraint queries", getNumberOfAddConstraintQueries())
.put("number of model queries", getNumberOfModelQueries())
.put("number of unsatCore queries", getNumberOfUnsatCoreQueries())
.put("number of isUnsat queries", getNumberOfIsUnsatQueries())
.put("sumTime of isUnsat queries", getSumTimeOfIsUnsatQueries())
.put("maxTime of isUnsat queries", getMaxTimeOfIsUnsatQueries())
.put("number of allSat queries", getNumberOfAllSatQueries())
.put("sumTime of allSat queries", getSumTimeOfAllSatQueries())
.put("maxTime of allSat queries", getMaxTimeOfAllSatQueries())
.put("number of interpolation queries", getNumberOfInterpolationQueries())
.put("sumTime of interpolation queries", getSumTimeOfInterpolationQueries())
.put("maxTime of interpolation queries", getMaxTimeOfInterpolationQueries())
.put("number of visits", getNumberOfVisits())
.put("number of Boolean operations", getNumberOfBooleanOperations())
.put("number of Numeric operations", getNumberOfNumericOperations())
.put("number of Array operations", getNumberOfArrayOperations())
.put("number of SL operations", getNumberOfSLOperations())
.put("number of UF operations", getNumberOfUFOperations())
.put("number of Quantifier operations", getNumberOfQuantifierOperations())
.put("number of BV operations", getNumberOfBVOperations())
.put("number of FP operations", getNumberOfFPOperations())
.put("number of String operations", getNumberOfStringOperations())
.put("number of model evaluation queries", getNumberOfModelEvaluationQueries())
.put("number of model listings", getNumberOfModelListings())
.buildOrThrow();
}
}
| 6,306 | 32.020942 | 87 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsArrayFormulaManager.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import org.sosy_lab.java_smt.api.ArrayFormula;
import org.sosy_lab.java_smt.api.ArrayFormulaManager;
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.ArrayFormulaType;
@SuppressWarnings({"ClassTypeParameterName", "MethodTypeParameterName"})
class StatisticsArrayFormulaManager implements ArrayFormulaManager {
private final ArrayFormulaManager delegate;
private final SolverStatistics stats;
StatisticsArrayFormulaManager(ArrayFormulaManager pDelegate, SolverStatistics pStats) {
delegate = checkNotNull(pDelegate);
stats = checkNotNull(pStats);
}
@Override
public <TI extends Formula, TE extends Formula> TE select(
ArrayFormula<TI, TE> pArray, TI pIndex) {
stats.arrayOperations.getAndIncrement();
return delegate.select(pArray, pIndex);
}
@Override
public <TI extends Formula, TE extends Formula> ArrayFormula<TI, TE> store(
ArrayFormula<TI, TE> pArray, TI pIndex, TE pValue) {
stats.arrayOperations.getAndIncrement();
return delegate.store(pArray, pIndex, pValue);
}
@Override
public <
TI extends Formula,
TE extends Formula,
FTI extends FormulaType<TI>,
FTE extends FormulaType<TE>>
ArrayFormula<TI, TE> makeArray(String pName, FTI pIndexType, FTE pElementType) {
stats.arrayOperations.getAndIncrement();
return delegate.makeArray(pName, pIndexType, pElementType);
}
@Override
public <TI extends Formula, TE extends Formula> ArrayFormula<TI, TE> makeArray(
String pName, ArrayFormulaType<TI, TE> pType) {
stats.arrayOperations.getAndIncrement();
return delegate.makeArray(pName, pType);
}
@Override
public <TI extends Formula, TE extends Formula> BooleanFormula equivalence(
ArrayFormula<TI, TE> pArray1, ArrayFormula<TI, TE> pArray2) {
stats.arrayOperations.getAndIncrement();
return delegate.equivalence(pArray1, pArray2);
}
@Override
public <TI extends Formula> FormulaType<TI> getIndexType(ArrayFormula<TI, ?> pArray) {
return delegate.getIndexType(pArray);
}
@Override
public <TE extends Formula> FormulaType<TE> getElementType(ArrayFormula<?, TE> pArray) {
return delegate.getElementType(pArray);
}
}
| 2,689 | 32.625 | 90 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsBasicProverEnvironment.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.sosy_lab.java_smt.api.BasicProverEnvironment;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.Model;
import org.sosy_lab.java_smt.api.SolverException;
import org.sosy_lab.java_smt.delegate.statistics.TimerPool.TimerWrapper;
class StatisticsBasicProverEnvironment<T> implements BasicProverEnvironment<T> {
private final BasicProverEnvironment<T> delegate;
final SolverStatistics stats;
final TimerWrapper unsatTimer;
private final TimerWrapper allSatTimer;
StatisticsBasicProverEnvironment(BasicProverEnvironment<T> pDelegate, SolverStatistics pStats) {
delegate = checkNotNull(pDelegate);
stats = checkNotNull(pStats);
unsatTimer = stats.unsat.getNewTimer();
allSatTimer = stats.allSat.getNewTimer();
stats.provers.getAndIncrement();
}
@Override
public void pop() {
stats.pop.getAndIncrement();
delegate.pop();
}
@Override
public @Nullable T addConstraint(BooleanFormula pConstraint) throws InterruptedException {
stats.constraint.getAndIncrement();
return delegate.addConstraint(pConstraint);
}
@Override
public void push() throws InterruptedException {
stats.push.getAndIncrement();
delegate.push();
}
@Override
public int size() {
return delegate.size();
}
@Override
public boolean isUnsat() throws SolverException, InterruptedException {
unsatTimer.start();
try {
return delegate.isUnsat();
} finally {
unsatTimer.stop();
}
}
@Override
public boolean isUnsatWithAssumptions(Collection<BooleanFormula> pAssumptions)
throws SolverException, InterruptedException {
unsatTimer.start();
try {
return delegate.isUnsatWithAssumptions(pAssumptions);
} finally {
unsatTimer.stop();
}
}
@SuppressWarnings("resource")
@Override
public Model getModel() throws SolverException {
stats.model.getAndIncrement();
return new StatisticsModel(delegate.getModel(), stats);
}
@Override
public List<BooleanFormula> getUnsatCore() {
stats.unsatCore.getAndIncrement();
return delegate.getUnsatCore();
}
@Override
public Optional<List<BooleanFormula>> unsatCoreOverAssumptions(
Collection<BooleanFormula> pAssumptions) throws SolverException, InterruptedException {
stats.unsatCore.getAndIncrement();
return delegate.unsatCoreOverAssumptions(pAssumptions);
}
@Override
public void close() {
delegate.close();
}
@Override
public <R> R allSat(AllSatCallback<R> pCallback, List<BooleanFormula> pImportant)
throws InterruptedException, SolverException {
allSatTimer.start();
try {
return delegate.allSat(pCallback, pImportant);
} finally {
allSatTimer.stop();
}
}
}
| 3,255 | 26.59322 | 98 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsBitvectorFormulaManager.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import java.math.BigInteger;
import java.util.List;
import org.sosy_lab.java_smt.api.BitvectorFormula;
import org.sosy_lab.java_smt.api.BitvectorFormulaManager;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.FormulaType.BitvectorType;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
class StatisticsBitvectorFormulaManager implements BitvectorFormulaManager {
private final BitvectorFormulaManager delegate;
private final SolverStatistics stats;
StatisticsBitvectorFormulaManager(BitvectorFormulaManager pDelegate, SolverStatistics pStats) {
delegate = checkNotNull(pDelegate);
stats = checkNotNull(pStats);
}
@Override
public BitvectorFormula makeBitvector(int pLength, long pI) {
stats.bvOperations.getAndIncrement();
return delegate.makeBitvector(pLength, pI);
}
@Override
public BitvectorFormula makeBitvector(int pLength, BigInteger pI) {
stats.bvOperations.getAndIncrement();
return delegate.makeBitvector(pLength, pI);
}
@Override
public BitvectorFormula makeBitvector(int pLength, IntegerFormula pI) {
stats.bvOperations.getAndIncrement();
return delegate.makeBitvector(pLength, pI);
}
@Override
public IntegerFormula toIntegerFormula(BitvectorFormula pI, boolean pSigned) {
stats.bvOperations.getAndIncrement();
return delegate.toIntegerFormula(pI, pSigned);
}
@Override
public BitvectorFormula makeVariable(int pLength, String pVar) {
stats.bvOperations.getAndIncrement();
return delegate.makeVariable(pLength, pVar);
}
@Override
public BitvectorFormula makeVariable(BitvectorType pType, String pVar) {
stats.bvOperations.getAndIncrement();
return delegate.makeVariable(pType, pVar);
}
@Override
public int getLength(BitvectorFormula pNumber) {
return delegate.getLength(pNumber);
}
@Override
public BitvectorFormula negate(BitvectorFormula pNumber) {
stats.bvOperations.getAndIncrement();
return delegate.negate(pNumber);
}
@Override
public BitvectorFormula add(BitvectorFormula pNumber1, BitvectorFormula pNumber2) {
stats.bvOperations.getAndIncrement();
return delegate.add(pNumber1, pNumber2);
}
@Override
public BitvectorFormula subtract(BitvectorFormula pNumber1, BitvectorFormula pNumber2) {
stats.bvOperations.getAndIncrement();
return delegate.subtract(pNumber1, pNumber2);
}
@Override
public BitvectorFormula divide(
BitvectorFormula pNumber1, BitvectorFormula pNumber2, boolean pSigned) {
stats.bvOperations.getAndIncrement();
return delegate.divide(pNumber1, pNumber2, pSigned);
}
@Override
public BitvectorFormula modulo(
BitvectorFormula pNumber1, BitvectorFormula pNumber2, boolean pSigned) {
stats.bvOperations.getAndIncrement();
return delegate.modulo(pNumber1, pNumber2, pSigned);
}
@Override
public BitvectorFormula multiply(BitvectorFormula pNumber1, BitvectorFormula pNumber2) {
stats.bvOperations.getAndIncrement();
return delegate.multiply(pNumber1, pNumber2);
}
@Override
public BooleanFormula equal(BitvectorFormula pNumber1, BitvectorFormula pNumber2) {
stats.bvOperations.getAndIncrement();
return delegate.equal(pNumber1, pNumber2);
}
@Override
public BooleanFormula greaterThan(
BitvectorFormula pNumber1, BitvectorFormula pNumber2, boolean pSigned) {
stats.bvOperations.getAndIncrement();
return delegate.greaterThan(pNumber1, pNumber2, pSigned);
}
@Override
public BooleanFormula greaterOrEquals(
BitvectorFormula pNumber1, BitvectorFormula pNumber2, boolean pSigned) {
stats.bvOperations.getAndIncrement();
return delegate.greaterOrEquals(pNumber1, pNumber2, pSigned);
}
@Override
public BooleanFormula lessThan(
BitvectorFormula pNumber1, BitvectorFormula pNumber2, boolean pSigned) {
stats.bvOperations.getAndIncrement();
return delegate.lessThan(pNumber1, pNumber2, pSigned);
}
@Override
public BooleanFormula lessOrEquals(
BitvectorFormula pNumber1, BitvectorFormula pNumber2, boolean pSigned) {
stats.bvOperations.getAndIncrement();
return delegate.lessOrEquals(pNumber1, pNumber2, pSigned);
}
@Override
public BitvectorFormula not(BitvectorFormula pBits) {
stats.bvOperations.getAndIncrement();
return delegate.not(pBits);
}
@Override
public BitvectorFormula and(BitvectorFormula pBits1, BitvectorFormula pBits2) {
stats.bvOperations.getAndIncrement();
return delegate.and(pBits1, pBits2);
}
@Override
public BitvectorFormula or(BitvectorFormula pBits1, BitvectorFormula pBits2) {
stats.bvOperations.getAndIncrement();
return delegate.or(pBits1, pBits2);
}
@Override
public BitvectorFormula xor(BitvectorFormula pBits1, BitvectorFormula pBits2) {
stats.bvOperations.getAndIncrement();
return delegate.xor(pBits1, pBits2);
}
@Override
public BitvectorFormula shiftRight(
BitvectorFormula pNumber, BitvectorFormula pToShift, boolean pSigned) {
stats.bvOperations.getAndIncrement();
return delegate.shiftRight(pNumber, pToShift, pSigned);
}
@Override
public BitvectorFormula shiftLeft(BitvectorFormula pNumber, BitvectorFormula pToShift) {
stats.bvOperations.getAndIncrement();
return delegate.shiftLeft(pNumber, pToShift);
}
@Override
public BitvectorFormula concat(BitvectorFormula pNumber, BitvectorFormula pAppend) {
stats.bvOperations.getAndIncrement();
return delegate.concat(pNumber, pAppend);
}
@Override
public BitvectorFormula extract(BitvectorFormula pNumber, int pMsb, int pLsb) {
stats.bvOperations.getAndIncrement();
return delegate.extract(pNumber, pMsb, pLsb);
}
@Override
public BitvectorFormula extend(BitvectorFormula pNumber, int pExtensionBits, boolean pSigned) {
stats.bvOperations.getAndIncrement();
return delegate.extend(pNumber, pExtensionBits, pSigned);
}
@Override
public BooleanFormula distinct(List<BitvectorFormula> pBits) {
stats.bvOperations.getAndIncrement();
return delegate.distinct(pBits);
}
}
| 6,462 | 30.526829 | 97 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsBooleanFormulaManager.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Collection;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.BooleanFormulaManager;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.visitors.BooleanFormulaTransformationVisitor;
import org.sosy_lab.java_smt.api.visitors.BooleanFormulaVisitor;
import org.sosy_lab.java_smt.api.visitors.TraversalProcess;
class StatisticsBooleanFormulaManager implements BooleanFormulaManager {
private final BooleanFormulaManager delegate;
private final SolverStatistics stats;
StatisticsBooleanFormulaManager(BooleanFormulaManager pDelegate, SolverStatistics pStats) {
delegate = checkNotNull(pDelegate);
stats = checkNotNull(pStats);
}
@Override
public BooleanFormula makeTrue() {
stats.booleanOperations.getAndIncrement();
return delegate.makeTrue();
}
@Override
public BooleanFormula makeFalse() {
stats.booleanOperations.getAndIncrement();
return delegate.makeFalse();
}
@Override
public BooleanFormula makeVariable(String pVar) {
stats.booleanOperations.getAndIncrement();
return delegate.makeVariable(pVar);
}
@Override
public BooleanFormula equivalence(BooleanFormula pFormula1, BooleanFormula pFormula2) {
stats.booleanOperations.getAndIncrement();
return delegate.equivalence(pFormula1, pFormula2);
}
@Override
public BooleanFormula implication(BooleanFormula pFormula1, BooleanFormula pFormula2) {
stats.booleanOperations.getAndIncrement();
return delegate.implication(pFormula1, pFormula2);
}
@Override
public boolean isTrue(BooleanFormula pFormula) {
stats.booleanOperations.getAndIncrement();
return delegate.isTrue(pFormula);
}
@Override
public boolean isFalse(BooleanFormula pFormula) {
stats.booleanOperations.getAndIncrement();
return delegate.isFalse(pFormula);
}
@Override
public <T extends Formula> T ifThenElse(BooleanFormula pCond, T pF1, T pF2) {
stats.booleanOperations.getAndIncrement();
return delegate.ifThenElse(pCond, pF1, pF2);
}
@Override
public BooleanFormula not(BooleanFormula pBits) {
stats.booleanOperations.getAndIncrement();
return delegate.not(pBits);
}
@Override
public BooleanFormula and(BooleanFormula pBits1, BooleanFormula pBits2) {
stats.booleanOperations.getAndIncrement();
return delegate.and(pBits1, pBits2);
}
@Override
public BooleanFormula and(Collection<BooleanFormula> pBits) {
stats.booleanOperations.getAndIncrement();
return delegate.and(pBits);
}
@Override
public BooleanFormula and(BooleanFormula... pBits) {
stats.booleanOperations.getAndIncrement();
return delegate.and(pBits);
}
@Override
public Collector<BooleanFormula, ?, BooleanFormula> toConjunction() {
return Collectors.collectingAndThen(Collectors.toList(), this::and);
}
@Override
public BooleanFormula or(BooleanFormula pBits1, BooleanFormula pBits2) {
stats.booleanOperations.getAndIncrement();
return delegate.or(pBits1, pBits2);
}
@Override
public BooleanFormula or(Collection<BooleanFormula> pBits) {
stats.booleanOperations.getAndIncrement();
return delegate.or(pBits);
}
@Override
public BooleanFormula or(BooleanFormula... pBits) {
stats.booleanOperations.getAndIncrement();
return delegate.or(pBits);
}
@Override
public Collector<BooleanFormula, ?, BooleanFormula> toDisjunction() {
return Collectors.collectingAndThen(Collectors.toList(), this::or);
}
@Override
public BooleanFormula xor(BooleanFormula pBits1, BooleanFormula pBits2) {
stats.booleanOperations.getAndIncrement();
return delegate.xor(pBits1, pBits2);
}
@Override
public <R> R visit(BooleanFormula pFormula, BooleanFormulaVisitor<R> pVisitor) {
stats.visits.getAndIncrement();
return delegate.visit(pFormula, pVisitor);
}
@Override
public void visitRecursively(
BooleanFormula pF, BooleanFormulaVisitor<TraversalProcess> pRFormulaVisitor) {
stats.visits.getAndIncrement();
delegate.visitRecursively(pF, pRFormulaVisitor);
}
@Override
public BooleanFormula transformRecursively(
BooleanFormula pF, BooleanFormulaTransformationVisitor pVisitor) {
stats.visits.getAndIncrement();
return delegate.transformRecursively(pF, pVisitor);
}
@Override
public Set<BooleanFormula> toConjunctionArgs(BooleanFormula pF, boolean pFlatten) {
return delegate.toConjunctionArgs(pF, pFlatten);
}
@Override
public Set<BooleanFormula> toDisjunctionArgs(BooleanFormula pF, boolean pFlatten) {
return delegate.toDisjunctionArgs(pF, pFlatten);
}
}
| 5,088 | 28.935294 | 93 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsEnumerationFormulaManager.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Set;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.EnumerationFormula;
import org.sosy_lab.java_smt.api.EnumerationFormulaManager;
import org.sosy_lab.java_smt.api.FormulaType.EnumerationFormulaType;
public class StatisticsEnumerationFormulaManager implements EnumerationFormulaManager {
private final EnumerationFormulaManager delegate;
private final SolverStatistics stats;
StatisticsEnumerationFormulaManager(
EnumerationFormulaManager pDelegate, SolverStatistics pStats) {
delegate = checkNotNull(pDelegate);
stats = checkNotNull(pStats);
}
@Override
public EnumerationFormulaType declareEnumeration(String name, Set<String> elementNames) {
stats.enumerationDeclarations.getAndIncrement();
return delegate.declareEnumeration(name, elementNames);
}
@Override
public EnumerationFormula makeConstant(String pName, EnumerationFormulaType pType) {
stats.enumerationOperations.getAndIncrement();
return delegate.makeConstant(pName, pType);
}
@Override
public EnumerationFormula makeVariable(String pVar, EnumerationFormulaType pType) {
stats.enumerationOperations.getAndIncrement();
return delegate.makeVariable(pVar, pType);
}
@Override
public BooleanFormula equivalence(
EnumerationFormula pEnumeration1, EnumerationFormula pEnumeration2) {
stats.enumerationOperations.getAndIncrement();
return delegate.equivalence(pEnumeration1, pEnumeration2);
}
}
| 1,853 | 32.709091 | 91 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsFloatingPointFormulaManager.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import java.math.BigDecimal;
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.FloatingPointFormula;
import org.sosy_lab.java_smt.api.FloatingPointFormulaManager;
import org.sosy_lab.java_smt.api.FloatingPointRoundingMode;
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;
class StatisticsFloatingPointFormulaManager implements FloatingPointFormulaManager {
private final FloatingPointFormulaManager delegate;
private final SolverStatistics stats;
StatisticsFloatingPointFormulaManager(
FloatingPointFormulaManager pDelegate, SolverStatistics pStats) {
delegate = checkNotNull(pDelegate);
stats = checkNotNull(pStats);
}
@Override
public FloatingPointFormula makeNumber(double pN, FloatingPointType pType) {
stats.fpOperations.getAndIncrement();
return delegate.makeNumber(pN, pType);
}
@Override
public FloatingPointFormula makeNumber(
double pN, FloatingPointType pType, FloatingPointRoundingMode pFloatingPointRoundingMode) {
stats.fpOperations.getAndIncrement();
return delegate.makeNumber(pN, pType, pFloatingPointRoundingMode);
}
@Override
public FloatingPointFormula makeNumber(BigDecimal pN, FloatingPointType pType) {
stats.fpOperations.getAndIncrement();
return delegate.makeNumber(pN, pType);
}
@Override
public FloatingPointFormula makeNumber(
BigDecimal pN,
FloatingPointType pType,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
stats.fpOperations.getAndIncrement();
return delegate.makeNumber(pN, pType, pFloatingPointRoundingMode);
}
@Override
public FloatingPointFormula makeNumber(String pN, FloatingPointType pType) {
stats.fpOperations.getAndIncrement();
return delegate.makeNumber(pN, pType);
}
@Override
public FloatingPointFormula makeNumber(
String pN, FloatingPointType pType, FloatingPointRoundingMode pFloatingPointRoundingMode) {
stats.fpOperations.getAndIncrement();
return delegate.makeNumber(pN, pType, pFloatingPointRoundingMode);
}
@Override
public FloatingPointFormula makeNumber(Rational pN, FloatingPointType pType) {
stats.fpOperations.getAndIncrement();
return delegate.makeNumber(pN, pType);
}
@Override
public FloatingPointFormula makeNumber(
Rational pN, FloatingPointType pType, FloatingPointRoundingMode pFloatingPointRoundingMode) {
stats.fpOperations.getAndIncrement();
return delegate.makeNumber(pN, pType, pFloatingPointRoundingMode);
}
@Override
public FloatingPointFormula makeVariable(String pVar, FloatingPointType pType) {
stats.fpOperations.getAndIncrement();
return delegate.makeVariable(pVar, pType);
}
@Override
public FloatingPointFormula makePlusInfinity(FloatingPointType pType) {
stats.fpOperations.getAndIncrement();
return delegate.makePlusInfinity(pType);
}
@Override
public FloatingPointFormula makeMinusInfinity(FloatingPointType pType) {
stats.fpOperations.getAndIncrement();
return delegate.makeMinusInfinity(pType);
}
@Override
public FloatingPointFormula makeNaN(FloatingPointType pType) {
stats.fpOperations.getAndIncrement();
return delegate.makeNaN(pType);
}
@Override
public <T extends Formula> T castTo(
FloatingPointFormula pNumber, boolean pSigned, FormulaType<T> pTargetType) {
stats.fpOperations.getAndIncrement();
return delegate.castTo(pNumber, pSigned, pTargetType);
}
@Override
public <T extends Formula> T castTo(
FloatingPointFormula pNumber,
boolean pSigned,
FormulaType<T> pTargetType,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
stats.fpOperations.getAndIncrement();
return delegate.castTo(pNumber, pSigned, pTargetType, pFloatingPointRoundingMode);
}
@Override
public FloatingPointFormula castFrom(
Formula pSource, boolean pSigned, FloatingPointType pTargetType) {
stats.fpOperations.getAndIncrement();
return delegate.castFrom(pSource, pSigned, pTargetType);
}
@Override
public FloatingPointFormula castFrom(
Formula pSource,
boolean pSigned,
FloatingPointType pTargetType,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
stats.fpOperations.getAndIncrement();
return delegate.castFrom(pSource, pSigned, pTargetType, pFloatingPointRoundingMode);
}
@Override
public FloatingPointFormula fromIeeeBitvector(
BitvectorFormula pNumber, FloatingPointType pTargetType) {
stats.fpOperations.getAndIncrement();
return delegate.fromIeeeBitvector(pNumber, pTargetType);
}
@Override
public BitvectorFormula toIeeeBitvector(FloatingPointFormula pNumber) {
stats.fpOperations.getAndIncrement();
return delegate.toIeeeBitvector(pNumber);
}
@Override
public FloatingPointFormula round(
FloatingPointFormula pFormula, FloatingPointRoundingMode pRoundingMode) {
stats.fpOperations.getAndIncrement();
return delegate.round(pFormula, pRoundingMode);
}
@Override
public FloatingPointFormula negate(FloatingPointFormula pNumber) {
stats.fpOperations.getAndIncrement();
return delegate.negate(pNumber);
}
@Override
public FloatingPointFormula abs(FloatingPointFormula pNumber) {
stats.fpOperations.getAndIncrement();
return delegate.abs(pNumber);
}
@Override
public FloatingPointFormula max(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
stats.fpOperations.getAndIncrement();
return delegate.max(pNumber1, pNumber2);
}
@Override
public FloatingPointFormula min(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
stats.fpOperations.getAndIncrement();
return delegate.min(pNumber1, pNumber2);
}
@Override
public FloatingPointFormula sqrt(FloatingPointFormula pNumber) {
stats.fpOperations.getAndIncrement();
return delegate.sqrt(pNumber);
}
@Override
public FloatingPointFormula sqrt(
FloatingPointFormula pNumber, FloatingPointRoundingMode pRoundingMode) {
stats.fpOperations.getAndIncrement();
return delegate.sqrt(pNumber, pRoundingMode);
}
@Override
public FloatingPointFormula add(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
stats.fpOperations.getAndIncrement();
return delegate.add(pNumber1, pNumber2);
}
@Override
public FloatingPointFormula add(
FloatingPointFormula pNumber1,
FloatingPointFormula pNumber2,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
stats.fpOperations.getAndIncrement();
return delegate.add(pNumber1, pNumber2, pFloatingPointRoundingMode);
}
@Override
public FloatingPointFormula subtract(
FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
stats.fpOperations.getAndIncrement();
return delegate.subtract(pNumber1, pNumber2);
}
@Override
public FloatingPointFormula subtract(
FloatingPointFormula pNumber1,
FloatingPointFormula pNumber2,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
stats.fpOperations.getAndIncrement();
return delegate.subtract(pNumber1, pNumber2, pFloatingPointRoundingMode);
}
@Override
public FloatingPointFormula divide(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
stats.fpOperations.getAndIncrement();
return delegate.divide(pNumber1, pNumber2);
}
@Override
public FloatingPointFormula divide(
FloatingPointFormula pNumber1,
FloatingPointFormula pNumber2,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
stats.fpOperations.getAndIncrement();
return delegate.divide(pNumber1, pNumber2, pFloatingPointRoundingMode);
}
@Override
public FloatingPointFormula multiply(
FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
stats.fpOperations.getAndIncrement();
return delegate.multiply(pNumber1, pNumber2);
}
@Override
public FloatingPointFormula multiply(
FloatingPointFormula pNumber1,
FloatingPointFormula pNumber2,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
stats.fpOperations.getAndIncrement();
return delegate.multiply(pNumber1, pNumber2, pFloatingPointRoundingMode);
}
@Override
public BooleanFormula assignment(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
stats.fpOperations.getAndIncrement();
return delegate.assignment(pNumber1, pNumber2);
}
@Override
public BooleanFormula equalWithFPSemantics(
FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
stats.fpOperations.getAndIncrement();
return delegate.equalWithFPSemantics(pNumber1, pNumber2);
}
@Override
public BooleanFormula greaterThan(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
stats.fpOperations.getAndIncrement();
return delegate.greaterThan(pNumber1, pNumber2);
}
@Override
public BooleanFormula greaterOrEquals(
FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
stats.fpOperations.getAndIncrement();
return delegate.greaterOrEquals(pNumber1, pNumber2);
}
@Override
public BooleanFormula lessThan(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
stats.fpOperations.getAndIncrement();
return delegate.lessThan(pNumber1, pNumber2);
}
@Override
public BooleanFormula lessOrEquals(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
stats.fpOperations.getAndIncrement();
return delegate.lessOrEquals(pNumber1, pNumber2);
}
@Override
public BooleanFormula isNaN(FloatingPointFormula pNumber) {
stats.fpOperations.getAndIncrement();
return delegate.isNaN(pNumber);
}
@Override
public BooleanFormula isInfinity(FloatingPointFormula pNumber) {
stats.fpOperations.getAndIncrement();
return delegate.isInfinity(pNumber);
}
@Override
public BooleanFormula isZero(FloatingPointFormula pNumber) {
stats.fpOperations.getAndIncrement();
return delegate.isZero(pNumber);
}
@Override
public BooleanFormula isNormal(FloatingPointFormula pNumber) {
stats.fpOperations.getAndIncrement();
return delegate.isNormal(pNumber);
}
@Override
public BooleanFormula isSubnormal(FloatingPointFormula pNumber) {
stats.fpOperations.getAndIncrement();
return delegate.isSubnormal(pNumber);
}
@Override
public BooleanFormula isNegative(FloatingPointFormula pNumber) {
stats.fpOperations.getAndIncrement();
return delegate.isNegative(pNumber);
}
}
| 11,047 | 31.494118 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsFormulaManager.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.collect.ImmutableMap;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import org.sosy_lab.common.Appender;
import org.sosy_lab.common.Appenders;
import org.sosy_lab.java_smt.api.ArrayFormulaManager;
import org.sosy_lab.java_smt.api.BitvectorFormulaManager;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.BooleanFormulaManager;
import org.sosy_lab.java_smt.api.EnumerationFormulaManager;
import org.sosy_lab.java_smt.api.FloatingPointFormulaManager;
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.api.FunctionDeclaration;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.QuantifiedFormulaManager;
import org.sosy_lab.java_smt.api.RationalFormulaManager;
import org.sosy_lab.java_smt.api.SLFormulaManager;
import org.sosy_lab.java_smt.api.StringFormulaManager;
import org.sosy_lab.java_smt.api.Tactic;
import org.sosy_lab.java_smt.api.UFManager;
import org.sosy_lab.java_smt.api.visitors.FormulaTransformationVisitor;
import org.sosy_lab.java_smt.api.visitors.FormulaVisitor;
import org.sosy_lab.java_smt.api.visitors.TraversalProcess;
class StatisticsFormulaManager implements FormulaManager {
private final FormulaManager delegate;
private final SolverStatistics stats;
protected StatisticsFormulaManager(FormulaManager pDelegate, SolverStatistics pStats) {
delegate = checkNotNull(pDelegate);
stats = checkNotNull(pStats);
}
@Override
public IntegerFormulaManager getIntegerFormulaManager() {
return new StatisticsIntegerFormulaManager(delegate.getIntegerFormulaManager(), stats);
}
@Override
public RationalFormulaManager getRationalFormulaManager() {
return new StatisticsRationalFormulaManager(delegate.getRationalFormulaManager(), stats);
}
@Override
public BooleanFormulaManager getBooleanFormulaManager() {
return new StatisticsBooleanFormulaManager(delegate.getBooleanFormulaManager(), stats);
}
@Override
public ArrayFormulaManager getArrayFormulaManager() {
return new StatisticsArrayFormulaManager(delegate.getArrayFormulaManager(), stats);
}
@Override
public BitvectorFormulaManager getBitvectorFormulaManager() {
return new StatisticsBitvectorFormulaManager(delegate.getBitvectorFormulaManager(), stats);
}
@Override
public FloatingPointFormulaManager getFloatingPointFormulaManager() {
return new StatisticsFloatingPointFormulaManager(
delegate.getFloatingPointFormulaManager(), stats);
}
@Override
public UFManager getUFManager() {
return new StatisticsUFManager(delegate.getUFManager(), stats);
}
@Override
public SLFormulaManager getSLFormulaManager() {
return new StatisticsSLFormulaManager(delegate.getSLFormulaManager(), stats);
}
@Override
public QuantifiedFormulaManager getQuantifiedFormulaManager() {
return new StatisticsQuantifiedFormulaManager(delegate.getQuantifiedFormulaManager(), stats);
}
@Override
public StringFormulaManager getStringFormulaManager() {
return new StatisticsStringFormulaManager(delegate.getStringFormulaManager(), stats);
}
@Override
public EnumerationFormulaManager getEnumerationFormulaManager() {
return new StatisticsEnumerationFormulaManager(delegate.getEnumerationFormulaManager(), stats);
}
@Override
public <T extends Formula> T makeVariable(FormulaType<T> pFormulaType, String pName) {
return delegate.makeVariable(pFormulaType, pName);
}
@Override
public <T extends Formula> T makeApplication(
FunctionDeclaration<T> pDeclaration, List<? extends Formula> pArgs) {
return delegate.makeApplication(pDeclaration, pArgs);
}
@Override
public <T extends Formula> T makeApplication(
FunctionDeclaration<T> pDeclaration, Formula... pArgs) {
return delegate.makeApplication(pDeclaration, pArgs);
}
@Override
public <T extends Formula> FormulaType<T> getFormulaType(T pFormula) {
return delegate.getFormulaType(pFormula);
}
@Override
public BooleanFormula parse(String pS) throws IllegalArgumentException {
return delegate.parse(pS);
}
@Override
public Appender dumpFormula(BooleanFormula pT) {
return new Appenders.AbstractAppender() {
@Override
public void appendTo(Appendable out) throws IOException {
String dump;
dump = delegate.dumpFormula(pT).toString(); // the work is done here
out.append(dump);
}
};
}
@Override
public BooleanFormula applyTactic(BooleanFormula pInput, Tactic pTactic)
throws InterruptedException {
return delegate.applyTactic(pInput, pTactic);
}
@Override
public <T extends Formula> T simplify(T pInput) throws InterruptedException {
return delegate.simplify(pInput);
}
@Override
public <R> R visit(Formula pF, FormulaVisitor<R> pFormulaVisitor) {
return delegate.visit(pF, pFormulaVisitor);
}
@Override
public void visitRecursively(Formula pF, FormulaVisitor<TraversalProcess> pFormulaVisitor) {
delegate.visitRecursively(pF, pFormulaVisitor);
}
@Override
public <T extends Formula> T transformRecursively(
T pF, FormulaTransformationVisitor pFormulaVisitor) {
return delegate.transformRecursively(pF, pFormulaVisitor);
}
@Override
public ImmutableMap<String, Formula> extractVariables(Formula pF) {
return delegate.extractVariables(pF);
}
@Override
public ImmutableMap<String, Formula> extractVariablesAndUFs(Formula pF) {
return delegate.extractVariablesAndUFs(pF);
}
@Override
public <T extends Formula> T substitute(
T pF, Map<? extends Formula, ? extends Formula> pFromToMapping) {
return delegate.substitute(pF, pFromToMapping);
}
@Override
public BooleanFormula translateFrom(BooleanFormula pFormula, FormulaManager pOtherContext) {
return delegate.translateFrom(pFormula, pOtherContext);
}
@Override
public boolean isValidName(String pVariableName) {
return delegate.isValidName(pVariableName);
}
@Override
public String escape(String pVariableName) {
return delegate.escape(pVariableName);
}
@Override
public String unescape(String pVariableName) {
return delegate.unescape(pVariableName);
}
}
| 6,706 | 31.245192 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsIntegerFormulaManager.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import java.math.BigInteger;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
class StatisticsIntegerFormulaManager
extends StatisticsNumeralFormulaManager<IntegerFormula, IntegerFormula>
implements IntegerFormulaManager {
private final IntegerFormulaManager delegate;
StatisticsIntegerFormulaManager(IntegerFormulaManager pDelegate, SolverStatistics pStats) {
super(pDelegate, pStats);
delegate = checkNotNull(pDelegate);
}
@Override
public BooleanFormula modularCongruence(
IntegerFormula pNumber1, IntegerFormula pNumber2, BigInteger pN) {
stats.numericOperations.getAndIncrement();
return delegate.modularCongruence(pNumber1, pNumber2, pN);
}
@Override
public BooleanFormula modularCongruence(
IntegerFormula pNumber1, IntegerFormula pNumber2, long pN) {
stats.numericOperations.getAndIncrement();
return delegate.modularCongruence(pNumber1, pNumber2, pN);
}
@Override
public IntegerFormula modulo(IntegerFormula pNumber1, IntegerFormula pNumber2) {
stats.numericOperations.getAndIncrement();
return delegate.modulo(pNumber1, pNumber2);
}
}
| 1,605 | 31.77551 | 93 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsInterpolatingProverEnvironment.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.delegate.statistics;
import java.util.Collection;
import java.util.List;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
import org.sosy_lab.java_smt.api.SolverException;
import org.sosy_lab.java_smt.delegate.statistics.TimerPool.TimerWrapper;
class StatisticsInterpolatingProverEnvironment<T> extends StatisticsBasicProverEnvironment<T>
implements InterpolatingProverEnvironment<T> {
private final InterpolatingProverEnvironment<T> delegate;
private final TimerWrapper itpTimer;
StatisticsInterpolatingProverEnvironment(
InterpolatingProverEnvironment<T> pDelegate, SolverStatistics pStats) {
super(pDelegate, pStats);
delegate = pDelegate;
itpTimer = stats.interpolation.getNewTimer();
}
@Override
public BooleanFormula getInterpolant(Collection<T> pFormulasOfA)
throws SolverException, InterruptedException {
itpTimer.start();
try {
return delegate.getInterpolant(pFormulasOfA);
} finally {
itpTimer.stop();
}
}
@Override
public List<BooleanFormula> getSeqInterpolants(List<? extends Collection<T>> pPartitionedFormulas)
throws SolverException, InterruptedException {
itpTimer.start();
try {
return delegate.getSeqInterpolants(pPartitionedFormulas);
} finally {
itpTimer.stop();
}
}
@Override
public List<BooleanFormula> getTreeInterpolants(
List<? extends Collection<T>> pPartitionedFormulas, int[] pStartOfSubTree)
throws SolverException, InterruptedException {
itpTimer.start();
try {
return delegate.getTreeInterpolants(pPartitionedFormulas, pStartOfSubTree);
} finally {
itpTimer.stop();
}
}
}
| 2,001 | 29.8 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsModel.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.collect.ImmutableList;
import java.math.BigInteger;
import org.checkerframework.checker.nullness.qual.Nullable;
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.EnumerationFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.Model;
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.StringFormula;
class StatisticsModel implements Model {
private final Model delegate;
private final SolverStatistics stats;
StatisticsModel(Model pDelegate, SolverStatistics pStats) {
delegate = checkNotNull(pDelegate);
stats = checkNotNull(pStats);
}
@Override
public <T extends Formula> @Nullable T eval(T pFormula) {
stats.modelEvaluations.getAndIncrement();
return delegate.eval(pFormula);
}
@Override
public @Nullable Object evaluate(Formula pF) {
stats.modelEvaluations.getAndIncrement();
return delegate.evaluate(pF);
}
@Override
public @Nullable BigInteger evaluate(IntegerFormula pF) {
stats.modelEvaluations.getAndIncrement();
return delegate.evaluate(pF);
}
@Override
public @Nullable Rational evaluate(RationalFormula pF) {
stats.modelEvaluations.getAndIncrement();
return delegate.evaluate(pF);
}
@Override
public @Nullable Boolean evaluate(BooleanFormula pF) {
stats.modelEvaluations.getAndIncrement();
return delegate.evaluate(pF);
}
@Override
public @Nullable BigInteger evaluate(BitvectorFormula pF) {
stats.modelEvaluations.getAndIncrement();
return delegate.evaluate(pF);
}
@Override
public @Nullable String evaluate(StringFormula pF) {
stats.modelEvaluations.getAndIncrement();
return delegate.evaluate(pF);
}
@Override
public @Nullable String evaluate(EnumerationFormula pF) {
stats.modelEvaluations.getAndIncrement();
return delegate.evaluate(pF);
}
@Override
public ImmutableList<ValueAssignment> asList() {
stats.modelListings.getAndIncrement();
return delegate.asList();
}
@Override
public void close() {
delegate.close();
}
}
| 2,656 | 26.968421 | 69 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsNumeralFormulaManager.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.List;
import org.sosy_lab.common.rationals.Rational;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.NumeralFormula;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.NumeralFormulaManager;
@SuppressWarnings("ClassTypeParameterName")
class StatisticsNumeralFormulaManager<
ParamFormulaType extends NumeralFormula, ResultFormulaType extends NumeralFormula>
implements NumeralFormulaManager<ParamFormulaType, ResultFormulaType> {
private final NumeralFormulaManager<ParamFormulaType, ResultFormulaType> delegate;
final SolverStatistics stats;
StatisticsNumeralFormulaManager(
NumeralFormulaManager<ParamFormulaType, ResultFormulaType> pDelegate,
SolverStatistics pStats) {
delegate = checkNotNull(pDelegate);
stats = checkNotNull(pStats);
}
@Override
public ResultFormulaType makeNumber(long pNumber) {
stats.numericOperations.getAndIncrement();
return delegate.makeNumber(pNumber);
}
@Override
public ResultFormulaType makeNumber(BigInteger pNumber) {
stats.numericOperations.getAndIncrement();
return delegate.makeNumber(pNumber);
}
@Override
public ResultFormulaType makeNumber(double pNumber) {
stats.numericOperations.getAndIncrement();
return delegate.makeNumber(pNumber);
}
@Override
public ResultFormulaType makeNumber(BigDecimal pNumber) {
stats.numericOperations.getAndIncrement();
return delegate.makeNumber(pNumber);
}
@Override
public ResultFormulaType makeNumber(String pI) {
stats.numericOperations.getAndIncrement();
return delegate.makeNumber(pI);
}
@Override
public ResultFormulaType makeNumber(Rational pRational) {
stats.numericOperations.getAndIncrement();
return delegate.makeNumber(pRational);
}
@Override
public ResultFormulaType makeVariable(String pVar) {
stats.numericOperations.getAndIncrement();
return delegate.makeVariable(pVar);
}
@Override
public FormulaType<ResultFormulaType> getFormulaType() {
stats.numericOperations.getAndIncrement();
return delegate.getFormulaType();
}
@Override
public ResultFormulaType negate(ParamFormulaType pNumber) {
stats.numericOperations.getAndIncrement();
return delegate.negate(pNumber);
}
@Override
public ResultFormulaType add(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
stats.numericOperations.getAndIncrement();
return delegate.add(pNumber1, pNumber2);
}
@Override
public ResultFormulaType sum(List<ParamFormulaType> pOperands) {
stats.numericOperations.getAndIncrement();
return delegate.sum(pOperands);
}
@Override
public ResultFormulaType subtract(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
stats.numericOperations.getAndIncrement();
return delegate.subtract(pNumber1, pNumber2);
}
@Override
public ResultFormulaType divide(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
stats.numericOperations.getAndIncrement();
return delegate.divide(pNumber1, pNumber2);
}
@Override
public ResultFormulaType multiply(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
stats.numericOperations.getAndIncrement();
return delegate.multiply(pNumber1, pNumber2);
}
@Override
public BooleanFormula equal(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
stats.numericOperations.getAndIncrement();
return delegate.equal(pNumber1, pNumber2);
}
@Override
public BooleanFormula distinct(List<ParamFormulaType> pNumbers) {
stats.numericOperations.getAndIncrement();
return delegate.distinct(pNumbers);
}
@Override
public BooleanFormula greaterThan(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
stats.numericOperations.getAndIncrement();
return delegate.greaterThan(pNumber1, pNumber2);
}
@Override
public BooleanFormula greaterOrEquals(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
stats.numericOperations.getAndIncrement();
return delegate.greaterOrEquals(pNumber1, pNumber2);
}
@Override
public BooleanFormula lessThan(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
stats.numericOperations.getAndIncrement();
return delegate.lessThan(pNumber1, pNumber2);
}
@Override
public BooleanFormula lessOrEquals(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
stats.numericOperations.getAndIncrement();
return delegate.lessOrEquals(pNumber1, pNumber2);
}
@Override
public IntegerFormula floor(ParamFormulaType pNumber) {
stats.numericOperations.getAndIncrement();
return delegate.floor(pNumber);
}
}
| 5,139 | 30.341463 | 95 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsOptimizationProverEnvironment.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.delegate.statistics;
import java.util.Optional;
import org.sosy_lab.common.rationals.Rational;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.OptimizationProverEnvironment;
import org.sosy_lab.java_smt.api.SolverException;
class StatisticsOptimizationProverEnvironment extends StatisticsBasicProverEnvironment<Void>
implements OptimizationProverEnvironment {
private final OptimizationProverEnvironment delegate;
StatisticsOptimizationProverEnvironment(
OptimizationProverEnvironment pDelegate, SolverStatistics pStats) {
super(pDelegate, pStats);
delegate = pDelegate;
}
@Override
public int maximize(Formula pObjective) {
return delegate.maximize(pObjective);
}
@Override
public int minimize(Formula pObjective) {
return delegate.minimize(pObjective);
}
@Override
public OptStatus check() throws InterruptedException, SolverException {
unsatTimer.start();
try {
return delegate.check();
} finally {
unsatTimer.stop();
}
}
@Override
public Optional<Rational> upper(int pHandle, Rational pEpsilon) {
return delegate.upper(pHandle, pEpsilon);
}
@Override
public Optional<Rational> lower(int pHandle, Rational pEpsilon) {
return delegate.lower(pHandle, pEpsilon);
}
}
| 1,571 | 26.103448 | 92 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsProverEnvironment.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.delegate.statistics;
import org.sosy_lab.java_smt.api.BasicProverEnvironment;
import org.sosy_lab.java_smt.api.ProverEnvironment;
class StatisticsProverEnvironment extends StatisticsBasicProverEnvironment<Void>
implements ProverEnvironment {
StatisticsProverEnvironment(BasicProverEnvironment<Void> pDelegate, SolverStatistics pStats) {
super(pDelegate, pStats);
}
}
| 652 | 30.095238 | 96 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsQuantifiedFormulaManager.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.List;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.QuantifiedFormulaManager;
import org.sosy_lab.java_smt.api.SolverException;
class StatisticsQuantifiedFormulaManager implements QuantifiedFormulaManager {
private final QuantifiedFormulaManager delegate;
private final SolverStatistics stats;
StatisticsQuantifiedFormulaManager(QuantifiedFormulaManager pDelegate, SolverStatistics pStats) {
delegate = checkNotNull(pDelegate);
stats = checkNotNull(pStats);
}
@Override
public BooleanFormula mkQuantifier(
Quantifier pQ, List<? extends Formula> pVariables, BooleanFormula pBody) {
stats.quantifierOperations.getAndIncrement();
return delegate.mkQuantifier(pQ, pVariables, pBody);
}
@Override
public BooleanFormula eliminateQuantifiers(BooleanFormula pF)
throws InterruptedException, SolverException {
stats.quantifierOperations.getAndIncrement();
return delegate.eliminateQuantifiers(pF);
}
}
| 1,407 | 31.744186 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsRationalFormulaManager.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.delegate.statistics;
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 StatisticsRationalFormulaManager
extends StatisticsNumeralFormulaManager<NumeralFormula, RationalFormula>
implements RationalFormulaManager {
StatisticsRationalFormulaManager(RationalFormulaManager pDelegate, SolverStatistics pStats) {
super(pDelegate, pStats);
}
}
| 753 | 31.782609 | 95 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsSLFormulaManager.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
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.SLFormulaManager;
@SuppressWarnings({"ClassTypeParameterName", "MethodTypeParameterName"})
class StatisticsSLFormulaManager implements SLFormulaManager {
private final SLFormulaManager delegate;
private final SolverStatistics stats;
StatisticsSLFormulaManager(SLFormulaManager pDelegate, SolverStatistics pStats) {
delegate = checkNotNull(pDelegate);
stats = checkNotNull(pStats);
}
@Override
public BooleanFormula makeStar(BooleanFormula pF1, BooleanFormula pF2) {
stats.slOperations.getAndIncrement();
return delegate.makeStar(pF1, pF2);
}
@Override
public <AF extends Formula, VF extends Formula> BooleanFormula makePointsTo(AF pPtr, VF pTo) {
stats.slOperations.getAndIncrement();
return delegate.makePointsTo(pPtr, pTo);
}
@Override
public BooleanFormula makeMagicWand(BooleanFormula pF1, BooleanFormula pF2) {
stats.slOperations.getAndIncrement();
return delegate.makeMagicWand(pF1, pF2);
}
@Override
public <
AF extends Formula,
VF extends Formula,
AT extends FormulaType<AF>,
VT extends FormulaType<VF>>
BooleanFormula makeEmptyHeap(AT pAdressType, VT pValueType) {
stats.slOperations.getAndIncrement();
return delegate.makeEmptyHeap(pAdressType, pValueType);
}
@Override
public <AF extends Formula, AT extends FormulaType<AF>> AF makeNilElement(AT pAdressType) {
stats.slOperations.getAndIncrement();
return delegate.makeNilElement(pAdressType);
}
}
| 2,027 | 30.6875 | 96 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsSolverContext.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.collect.ImmutableMap;
import java.util.Map;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
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.api.SolverContext;
public class StatisticsSolverContext implements SolverContext {
private final SolverContext delegate;
private final SolverStatistics stats = new SolverStatistics();
public StatisticsSolverContext(SolverContext pDelegate) {
delegate = checkNotNull(pDelegate);
}
@Override
public FormulaManager getFormulaManager() {
return new StatisticsFormulaManager(delegate.getFormulaManager(), stats);
}
@SuppressWarnings("resource")
@Override
public ProverEnvironment newProverEnvironment(ProverOptions... pOptions) {
return new StatisticsProverEnvironment(delegate.newProverEnvironment(pOptions), stats);
}
@SuppressWarnings("resource")
@Override
public InterpolatingProverEnvironment<?> newProverEnvironmentWithInterpolation(
ProverOptions... pOptions) {
return new StatisticsInterpolatingProverEnvironment<>(
delegate.newProverEnvironmentWithInterpolation(pOptions), stats);
}
@SuppressWarnings("resource")
@Override
public OptimizationProverEnvironment newOptimizationProverEnvironment(ProverOptions... pOptions) {
return new StatisticsOptimizationProverEnvironment(
delegate.newOptimizationProverEnvironment(pOptions), stats);
}
@Override
public String getVersion() {
return delegate.getVersion();
}
@Override
public Solvers getSolverName() {
return delegate.getSolverName();
}
@Override
public ImmutableMap<String, String> getStatistics() {
ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
builder.putAll(delegate.getStatistics());
for (Map.Entry<String, Object> entry : getSolverStatistics().asMap().entrySet()) {
builder.put(entry.getKey(), entry.getValue().toString());
}
return builder.buildOrThrow();
}
@Override
public void close() {
delegate.close();
}
/** export statistics about the solver interaction. */
public SolverStatistics getSolverStatistics() {
return stats;
}
}
| 2,725 | 30.333333 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsStringFormulaManager.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 Alejandro Serrano Mena
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.List;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.NumeralFormula;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.RegexFormula;
import org.sosy_lab.java_smt.api.StringFormula;
import org.sosy_lab.java_smt.api.StringFormulaManager;
class StatisticsStringFormulaManager implements StringFormulaManager {
private final StringFormulaManager delegate;
private final SolverStatistics stats;
StatisticsStringFormulaManager(StringFormulaManager pDelegate, SolverStatistics pStats) {
delegate = checkNotNull(pDelegate);
stats = checkNotNull(pStats);
}
@Override
public StringFormula makeString(String value) {
stats.stringOperations.getAndIncrement();
return delegate.makeString(value);
}
@Override
public StringFormula makeVariable(String pVar) {
stats.stringOperations.getAndIncrement();
return delegate.makeVariable(pVar);
}
@Override
public BooleanFormula equal(StringFormula str1, StringFormula str2) {
stats.stringOperations.getAndIncrement();
return delegate.equal(str1, str2);
}
@Override
public BooleanFormula greaterThan(StringFormula str1, StringFormula str2) {
stats.stringOperations.getAndIncrement();
return delegate.greaterThan(str1, str2);
}
@Override
public BooleanFormula greaterOrEquals(StringFormula str1, StringFormula str2) {
stats.stringOperations.getAndIncrement();
return delegate.greaterOrEquals(str1, str2);
}
@Override
public BooleanFormula lessThan(StringFormula str1, StringFormula str2) {
stats.stringOperations.getAndIncrement();
return delegate.lessThan(str1, str2);
}
@Override
public BooleanFormula lessOrEquals(StringFormula str1, StringFormula str2) {
stats.stringOperations.getAndIncrement();
return delegate.lessOrEquals(str1, str2);
}
@Override
public NumeralFormula.IntegerFormula length(StringFormula str) {
stats.stringOperations.getAndIncrement();
return delegate.length(str);
}
@Override
public StringFormula concat(List<StringFormula> parts) {
stats.stringOperations.getAndIncrement();
return delegate.concat(parts);
}
@Override
public BooleanFormula prefix(StringFormula str1, StringFormula str2) {
stats.stringOperations.getAndIncrement();
return delegate.prefix(str1, str2);
}
@Override
public BooleanFormula suffix(StringFormula str1, StringFormula str2) {
stats.stringOperations.getAndIncrement();
return delegate.suffix(str1, str2);
}
@Override
public BooleanFormula contains(StringFormula str, StringFormula part) {
stats.stringOperations.getAndIncrement();
return delegate.contains(str, part);
}
@Override
public IntegerFormula indexOf(StringFormula str, StringFormula part, IntegerFormula startIndex) {
stats.stringOperations.getAndIncrement();
return delegate.indexOf(str, part, startIndex);
}
@Override
public StringFormula charAt(StringFormula str, IntegerFormula index) {
stats.stringOperations.getAndIncrement();
return delegate.charAt(str, index);
}
@Override
public StringFormula substring(StringFormula str, IntegerFormula index, IntegerFormula length) {
stats.stringOperations.getAndIncrement();
return delegate.substring(str, index, length);
}
@Override
public StringFormula replace(
StringFormula fullStr, StringFormula target, StringFormula replacement) {
stats.stringOperations.getAndIncrement();
return delegate.replace(fullStr, target, replacement);
}
@Override
public StringFormula replaceAll(
StringFormula fullStr, StringFormula target, StringFormula replacement) {
stats.stringOperations.getAndIncrement();
return delegate.replaceAll(fullStr, target, replacement);
}
@Override
public BooleanFormula in(StringFormula str, RegexFormula regex) {
stats.stringOperations.getAndIncrement();
return delegate.in(str, regex);
}
@Override
public RegexFormula makeRegex(String value) {
stats.stringOperations.getAndIncrement();
return delegate.makeRegex(value);
}
@Override
public RegexFormula none() {
stats.stringOperations.getAndIncrement();
return delegate.none();
}
@Override
public RegexFormula all() {
stats.stringOperations.getAndIncrement();
return delegate.all();
}
@Override
public RegexFormula allChar() {
stats.stringOperations.getAndIncrement();
return delegate.allChar();
}
@Override
public RegexFormula range(StringFormula start, StringFormula end) {
stats.stringOperations.getAndIncrement();
return delegate.range(start, end);
}
@Override
public RegexFormula concatRegex(List<RegexFormula> parts) {
stats.stringOperations.getAndIncrement();
return delegate.concatRegex(parts);
}
@Override
public RegexFormula union(RegexFormula regex1, RegexFormula regex2) {
stats.stringOperations.getAndIncrement();
return delegate.union(regex1, regex2);
}
@Override
public RegexFormula intersection(RegexFormula regex1, RegexFormula regex2) {
stats.stringOperations.getAndIncrement();
return delegate.intersection(regex1, regex2);
}
@Override
public RegexFormula closure(RegexFormula regex) {
stats.stringOperations.getAndIncrement();
return delegate.closure(regex);
}
@Override
public RegexFormula complement(RegexFormula regex) {
stats.stringOperations.getAndIncrement();
return delegate.complement(regex);
}
@Override
public RegexFormula difference(RegexFormula regex1, RegexFormula regex2) {
stats.stringOperations.getAndIncrement();
return delegate.difference(regex1, regex2);
}
@Override
public RegexFormula cross(RegexFormula regex) {
stats.stringOperations.getAndIncrement();
return delegate.cross(regex);
}
@Override
public RegexFormula optional(RegexFormula regex) {
stats.stringOperations.getAndIncrement();
return delegate.optional(regex);
}
@Override
public RegexFormula times(RegexFormula regex, int repetitions) {
stats.stringOperations.getAndIncrement();
return delegate.times(regex, repetitions);
}
@Override
public IntegerFormula toIntegerFormula(StringFormula str) {
stats.stringOperations.getAndIncrement();
return delegate.toIntegerFormula(str);
}
@Override
public StringFormula toStringFormula(IntegerFormula number) {
stats.stringOperations.getAndIncrement();
return delegate.toStringFormula(number);
}
}
| 6,873 | 28.004219 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsUFManager.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.delegate.statistics;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.List;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.FunctionDeclaration;
import org.sosy_lab.java_smt.api.UFManager;
class StatisticsUFManager implements UFManager {
private final UFManager delegate;
private final SolverStatistics stats;
StatisticsUFManager(UFManager pDelegate, SolverStatistics pStats) {
delegate = checkNotNull(pDelegate);
stats = checkNotNull(pStats);
}
@Override
public <T extends Formula> FunctionDeclaration<T> declareUF(
String pName, FormulaType<T> pReturnType, List<FormulaType<?>> pArgs) {
stats.ufOperations.getAndIncrement();
return delegate.declareUF(pName, pReturnType, pArgs);
}
@Override
public <T extends Formula> FunctionDeclaration<T> declareUF(
String pName, FormulaType<T> pReturnType, FormulaType<?>... pArgs) {
stats.ufOperations.getAndIncrement();
return delegate.declareUF(pName, pReturnType, pArgs);
}
@Override
public <T extends Formula> T callUF(
FunctionDeclaration<T> pFuncType, List<? extends Formula> pArgs) {
stats.ufOperations.getAndIncrement();
return delegate.callUF(pFuncType, pArgs);
}
@Override
public <T extends Formula> T callUF(FunctionDeclaration<T> pFuncType, Formula... pArgs) {
stats.ufOperations.getAndIncrement();
return delegate.callUF(pFuncType, pArgs);
}
@Override
public <T extends Formula> T declareAndCallUF(
String pName, FormulaType<T> pReturnType, List<Formula> pArgs) {
stats.ufOperations.getAndIncrement();
return delegate.declareAndCallUF(pName, pReturnType, pArgs);
}
@Override
public <T extends Formula> T declareAndCallUF(
String pName, FormulaType<T> pReturnType, Formula... pArgs) {
stats.ufOperations.getAndIncrement();
return delegate.declareAndCallUF(pName, pReturnType, pArgs);
}
}
| 2,257 | 31.257143 | 91 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/TimerPool.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.delegate.statistics;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.IdentityHashMap;
import java.util.concurrent.TimeUnit;
import java.util.function.BiFunction;
import java.util.function.Function;
import org.sosy_lab.common.time.TimeSpan;
import org.sosy_lab.common.time.Timer;
public class TimerPool {
/** We assume one common unit for all sub-timers. */
private static final TimeUnit UNIT = new Timer().getMaxTime().getUnit();
/**
* This map contains all usable timers.
*
* <p>We use WeakReferences to avoid memory leak when deleting timers. WeakReference allows us to
* access the wrapped Timer before GC.
*/
private final IdentityHashMap<WeakReference<TimerWrapper>, Timer> activeTimers =
new IdentityHashMap<>();
private final ReferenceQueue<TimerWrapper> referenceQueue = new ReferenceQueue<>();
/**
* The sum of times of all intervals. This field should be accessed through {@link #getSumTime()}
* to account for a currently running interval.
*/
private long sumTime = 0;
/** The maximal time of all intervals. */
private long maxTime = 0;
/**
* The number of intervals. This field should be accessed through {@link #getNumberOfIntervals()}
* to account for a currently running interval.
*/
private int numberOfIntervals = 0;
public TimerPool() {}
public TimerWrapper getNewTimer() {
cleanupReferences();
Timer timer = new Timer();
TimerWrapper wrapper = new TimerWrapper(timer);
assert UNIT == timer.getSumTime().getUnit() : "sub-timers should use same unit";
synchronized (activeTimers) {
activeTimers.put(new WeakReference<>(wrapper, referenceQueue), timer);
}
return wrapper;
}
private void cleanupReferences() {
Reference<? extends TimerWrapper> ref;
while ((ref = referenceQueue.poll()) != null) {
synchronized (activeTimers) {
closeTimer(activeTimers.remove(ref));
}
}
}
/** Stop the given Timer and collect its values. */
private void closeTimer(Timer timer) {
timer.stopIfRunning();
sumTime += convert(timer.getSumTime());
maxTime = Math.max(maxTime, convert(timer.getMaxTime()));
numberOfIntervals += timer.getNumberOfIntervals();
}
private long convert(TimeSpan time) {
// we assume the same unit for all sub-timers.
return time.getSaturated(UNIT);
}
private long eval(Function<Timer, Long> f, BiFunction<Long, Long, Long> acc) {
long currentInterval = 0;
for (Timer timer : activeTimers.values()) {
currentInterval = acc.apply(currentInterval, f.apply(timer));
}
return currentInterval;
}
/*
* Return the sum of all intervals. If timers are running, the current intervals are also counted
* (up to the current time). If no timer was started, this method returns 0.
*/
public TimeSpan getSumTime() {
cleanupReferences();
synchronized (activeTimers) {
return export(sumTime + eval(t -> convert(t.getSumTime()), Math::addExact));
}
}
/**
* Return the maximal time of all intervals. If timers are running, the current intervals are also
* counted (up to the current time). If no timer was started, this method returns 0.
*/
public TimeSpan getMaxTime() {
cleanupReferences();
synchronized (activeTimers) {
return export(Math.max(maxTime, eval(t -> convert(t.getMaxTime()), Math::max)));
}
}
/**
* Return the number of intervals. If timers are running, the current intervals are also counted.
* If no timer was started, this method returns 0.
*/
public int getNumberOfIntervals() {
cleanupReferences();
synchronized (activeTimers) {
return (int) (numberOfIntervals + eval(t -> (long) t.getNumberOfIntervals(), Math::addExact));
}
}
private TimeSpan export(long time) {
return TimeSpan.of(time, UNIT);
}
@Override
public String toString() {
cleanupReferences();
return getSumTime().formatAs(TimeUnit.SECONDS);
}
/** A minimal wrapper to keep a reference on the timer and provide a limited view. */
public static class TimerWrapper {
private final Timer timer;
TimerWrapper(Timer pTimer) {
timer = pTimer;
}
public void start() {
timer.start();
}
public void stop() {
timer.stop();
}
}
}
| 4,638 | 28.929032 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/statistics/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
/**
* The classes of this package wrap the whole proving environment and measure all accesses to it.
*/
@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.delegate.statistics;
| 621 | 35.588235 | 97 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedArrayFormulaManager.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import org.sosy_lab.java_smt.api.ArrayFormula;
import org.sosy_lab.java_smt.api.ArrayFormulaManager;
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.ArrayFormulaType;
import org.sosy_lab.java_smt.api.SolverContext;
@SuppressWarnings({"ClassTypeParameterName", "MethodTypeParameterName"})
class SynchronizedArrayFormulaManager implements ArrayFormulaManager {
private final ArrayFormulaManager delegate;
private final SolverContext sync;
SynchronizedArrayFormulaManager(ArrayFormulaManager pDelegate, SolverContext pSync) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
}
@Override
public <TI extends Formula, TE extends Formula> TE select(
ArrayFormula<TI, TE> pArray, TI pIndex) {
synchronized (sync) {
return delegate.select(pArray, pIndex);
}
}
@Override
public <TI extends Formula, TE extends Formula> ArrayFormula<TI, TE> store(
ArrayFormula<TI, TE> pArray, TI pIndex, TE pValue) {
synchronized (sync) {
return delegate.store(pArray, pIndex, pValue);
}
}
@Override
public <
TI extends Formula,
TE extends Formula,
FTI extends FormulaType<TI>,
FTE extends FormulaType<TE>>
ArrayFormula<TI, TE> makeArray(String pName, FTI pIndexType, FTE pElementType) {
synchronized (sync) {
return delegate.makeArray(pName, pIndexType, pElementType);
}
}
@Override
public <TI extends Formula, TE extends Formula> ArrayFormula<TI, TE> makeArray(
String pName, ArrayFormulaType<TI, TE> pType) {
synchronized (sync) {
return delegate.makeArray(pName, pType);
}
}
@Override
public <TI extends Formula, TE extends Formula> BooleanFormula equivalence(
ArrayFormula<TI, TE> pArray1, ArrayFormula<TI, TE> pArray2) {
synchronized (sync) {
return delegate.equivalence(pArray1, pArray2);
}
}
@Override
public <TI extends Formula> FormulaType<TI> getIndexType(ArrayFormula<TI, ?> pArray) {
synchronized (sync) {
return delegate.getIndexType(pArray);
}
}
@Override
public <TE extends Formula> FormulaType<TE> getElementType(ArrayFormula<?, TE> pArray) {
synchronized (sync) {
return delegate.getElementType(pArray);
}
}
}
| 2,745 | 29.511111 | 90 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedBasicProverEnvironment.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.collect.ImmutableMap;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.sosy_lab.java_smt.api.BasicProverEnvironment;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.Model;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverException;
class SynchronizedBasicProverEnvironment<T> implements BasicProverEnvironment<T> {
private final BasicProverEnvironment<T> delegate;
final SolverContext sync;
SynchronizedBasicProverEnvironment(BasicProverEnvironment<T> pDelegate, SolverContext pSync) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
}
@Override
public void pop() {
synchronized (sync) {
delegate.pop();
}
}
@Override
public @Nullable T addConstraint(BooleanFormula pConstraint) throws InterruptedException {
synchronized (sync) {
return delegate.addConstraint(pConstraint);
}
}
@Override
public void push() throws InterruptedException {
synchronized (sync) {
delegate.push();
}
}
@Override
public int size() {
synchronized (sync) {
return delegate.size();
}
}
@Override
public boolean isUnsat() throws SolverException, InterruptedException {
synchronized (sync) {
return delegate.isUnsat();
}
}
@Override
public boolean isUnsatWithAssumptions(Collection<BooleanFormula> pAssumptions)
throws SolverException, InterruptedException {
synchronized (sync) {
return delegate.isUnsatWithAssumptions(pAssumptions);
}
}
@SuppressWarnings("resource")
@Override
public Model getModel() throws SolverException {
synchronized (sync) {
return new SynchronizedModel(delegate.getModel(), sync);
}
}
@Override
public List<BooleanFormula> getUnsatCore() {
synchronized (sync) {
return delegate.getUnsatCore();
}
}
@Override
public Optional<List<BooleanFormula>> unsatCoreOverAssumptions(
Collection<BooleanFormula> pAssumptions) throws SolverException, InterruptedException {
synchronized (sync) {
return delegate.unsatCoreOverAssumptions(pAssumptions);
}
}
@Override
public ImmutableMap<String, String> getStatistics() {
synchronized (sync) {
return delegate.getStatistics();
}
}
@Override
public void close() {
synchronized (sync) {
delegate.close();
}
}
@Override
public <R> R allSat(AllSatCallback<R> pCallback, List<BooleanFormula> pImportant)
throws InterruptedException, SolverException {
synchronized (sync) {
return delegate.allSat(pCallback, pImportant);
}
}
}
| 3,118 | 24.565574 | 96 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedBasicProverEnvironmentWithContext.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.sosy_lab.java_smt.api.BasicProverEnvironment;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.FormulaManager;
import org.sosy_lab.java_smt.api.Model;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverException;
class SynchronizedBasicProverEnvironmentWithContext<T> implements BasicProverEnvironment<T> {
private final BasicProverEnvironment<T> delegate;
final FormulaManager manager;
final FormulaManager otherManager;
final SolverContext sync;
SynchronizedBasicProverEnvironmentWithContext(
BasicProverEnvironment<T> pDelegate,
SolverContext pSync,
FormulaManager pManager,
FormulaManager pOtherManager) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
manager = checkNotNull(pManager);
otherManager = checkNotNull(pOtherManager);
}
List<BooleanFormula> translate(
Collection<BooleanFormula> fs, FormulaManager from, FormulaManager to) {
ImmutableList.Builder<BooleanFormula> result = ImmutableList.builder();
synchronized (sync) {
for (BooleanFormula f : fs) {
result.add(to.translateFrom(f, from));
}
}
return result.build();
}
@Override
public void pop() {
delegate.pop();
}
@Override
public @Nullable T addConstraint(BooleanFormula pConstraint) throws InterruptedException {
BooleanFormula constraint;
synchronized (sync) {
constraint = otherManager.translateFrom(pConstraint, manager);
}
return delegate.addConstraint(constraint);
}
@Override
public void push() throws InterruptedException {
delegate.push();
}
@Override
public int size() {
synchronized (sync) {
return delegate.size();
}
}
@Override
public boolean isUnsat() throws SolverException, InterruptedException {
return delegate.isUnsat();
}
@Override
public boolean isUnsatWithAssumptions(Collection<BooleanFormula> pAssumptions)
throws SolverException, InterruptedException {
return delegate.isUnsatWithAssumptions(translate(pAssumptions, manager, otherManager));
}
@SuppressWarnings("resource")
@Override
public Model getModel() throws SolverException {
synchronized (sync) {
return new SynchronizedModelWithContext(delegate.getModel(), sync, manager, otherManager);
}
}
@Override
public List<BooleanFormula> getUnsatCore() {
return translate(delegate.getUnsatCore(), otherManager, manager);
}
@Override
public Optional<List<BooleanFormula>> unsatCoreOverAssumptions(
Collection<BooleanFormula> pAssumptions) throws SolverException, InterruptedException {
Optional<List<BooleanFormula>> core =
delegate.unsatCoreOverAssumptions(translate(pAssumptions, manager, otherManager));
if (core.isPresent()) {
return Optional.of(translate(core.orElseThrow(), otherManager, manager));
} else {
return Optional.empty();
}
}
@Override
public ImmutableMap<String, String> getStatistics() {
synchronized (sync) {
return delegate.getStatistics();
}
}
@Override
public void close() {
synchronized (sync) {
delegate.close();
}
}
@Override
public <R> R allSat(AllSatCallback<R> pCallback, List<BooleanFormula> pImportant)
throws InterruptedException, SolverException {
AllSatCallback<R> callback = new AllSatCallbackWithContext<>(pCallback);
synchronized (sync) {
return delegate.allSat(callback, translate(pImportant, manager, otherManager));
}
}
private class AllSatCallbackWithContext<R> implements AllSatCallback<R> {
private final AllSatCallback<R> delegateCallback;
AllSatCallbackWithContext(AllSatCallback<R> pDelegateCallback) {
delegateCallback = checkNotNull(pDelegateCallback);
}
@Override
public void apply(List<BooleanFormula> pModel) {
delegateCallback.apply(translate(pModel, otherManager, manager));
}
@Override
public R getResult() throws InterruptedException {
return delegateCallback.getResult();
}
}
}
| 4,687 | 28.484277 | 96 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedBitvectorFormulaManager.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import java.math.BigInteger;
import java.util.List;
import org.sosy_lab.java_smt.api.BitvectorFormula;
import org.sosy_lab.java_smt.api.BitvectorFormulaManager;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.FormulaType.BitvectorType;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.SolverContext;
class SynchronizedBitvectorFormulaManager implements BitvectorFormulaManager {
private final BitvectorFormulaManager delegate;
private final SolverContext sync;
SynchronizedBitvectorFormulaManager(BitvectorFormulaManager pDelegate, SolverContext pSync) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
}
@Override
public BitvectorFormula makeBitvector(int pLength, long pI) {
synchronized (sync) {
return delegate.makeBitvector(pLength, pI);
}
}
@Override
public BitvectorFormula makeBitvector(int pLength, BigInteger pI) {
synchronized (sync) {
return delegate.makeBitvector(pLength, pI);
}
}
@Override
public BitvectorFormula makeBitvector(int pLength, IntegerFormula pI) {
synchronized (sync) {
return delegate.makeBitvector(pLength, pI);
}
}
@Override
public IntegerFormula toIntegerFormula(BitvectorFormula pI, boolean pSigned) {
synchronized (sync) {
return delegate.toIntegerFormula(pI, pSigned);
}
}
@Override
public BitvectorFormula makeVariable(int pLength, String pVar) {
synchronized (sync) {
return delegate.makeVariable(pLength, pVar);
}
}
@Override
public BitvectorFormula makeVariable(BitvectorType pType, String pVar) {
synchronized (sync) {
return delegate.makeVariable(pType, pVar);
}
}
@Override
public int getLength(BitvectorFormula pNumber) {
synchronized (sync) {
return delegate.getLength(pNumber);
}
}
@Override
public BitvectorFormula negate(BitvectorFormula pNumber) {
synchronized (sync) {
return delegate.negate(pNumber);
}
}
@Override
public BitvectorFormula add(BitvectorFormula pNumber1, BitvectorFormula pNumber2) {
synchronized (sync) {
return delegate.add(pNumber1, pNumber2);
}
}
@Override
public BitvectorFormula subtract(BitvectorFormula pNumber1, BitvectorFormula pNumber2) {
synchronized (sync) {
return delegate.subtract(pNumber1, pNumber2);
}
}
@Override
public BitvectorFormula divide(
BitvectorFormula pNumber1, BitvectorFormula pNumber2, boolean pSigned) {
synchronized (sync) {
return delegate.divide(pNumber1, pNumber2, pSigned);
}
}
@Override
public BitvectorFormula modulo(
BitvectorFormula pNumber1, BitvectorFormula pNumber2, boolean pSigned) {
synchronized (sync) {
return delegate.modulo(pNumber1, pNumber2, pSigned);
}
}
@Override
public BitvectorFormula multiply(BitvectorFormula pNumber1, BitvectorFormula pNumber2) {
synchronized (sync) {
return delegate.multiply(pNumber1, pNumber2);
}
}
@Override
public BooleanFormula equal(BitvectorFormula pNumber1, BitvectorFormula pNumber2) {
synchronized (sync) {
return delegate.equal(pNumber1, pNumber2);
}
}
@Override
public BooleanFormula greaterThan(
BitvectorFormula pNumber1, BitvectorFormula pNumber2, boolean pSigned) {
synchronized (sync) {
return delegate.greaterThan(pNumber1, pNumber2, pSigned);
}
}
@Override
public BooleanFormula greaterOrEquals(
BitvectorFormula pNumber1, BitvectorFormula pNumber2, boolean pSigned) {
synchronized (sync) {
return delegate.greaterOrEquals(pNumber1, pNumber2, pSigned);
}
}
@Override
public BooleanFormula lessThan(
BitvectorFormula pNumber1, BitvectorFormula pNumber2, boolean pSigned) {
synchronized (sync) {
return delegate.lessThan(pNumber1, pNumber2, pSigned);
}
}
@Override
public BooleanFormula lessOrEquals(
BitvectorFormula pNumber1, BitvectorFormula pNumber2, boolean pSigned) {
synchronized (sync) {
return delegate.lessOrEquals(pNumber1, pNumber2, pSigned);
}
}
@Override
public BitvectorFormula not(BitvectorFormula pBits) {
synchronized (sync) {
return delegate.not(pBits);
}
}
@Override
public BitvectorFormula and(BitvectorFormula pBits1, BitvectorFormula pBits2) {
synchronized (sync) {
return delegate.and(pBits1, pBits2);
}
}
@Override
public BitvectorFormula or(BitvectorFormula pBits1, BitvectorFormula pBits2) {
synchronized (sync) {
return delegate.or(pBits1, pBits2);
}
}
@Override
public BitvectorFormula xor(BitvectorFormula pBits1, BitvectorFormula pBits2) {
synchronized (sync) {
return delegate.xor(pBits1, pBits2);
}
}
@Override
public BitvectorFormula shiftRight(
BitvectorFormula pNumber, BitvectorFormula pToShift, boolean pSigned) {
synchronized (sync) {
return delegate.shiftRight(pNumber, pToShift, pSigned);
}
}
@Override
public BitvectorFormula shiftLeft(BitvectorFormula pNumber, BitvectorFormula pToShift) {
synchronized (sync) {
return delegate.shiftLeft(pNumber, pToShift);
}
}
@Override
public BitvectorFormula concat(BitvectorFormula pNumber, BitvectorFormula pAppend) {
synchronized (sync) {
return delegate.concat(pNumber, pAppend);
}
}
@Override
public BitvectorFormula extract(BitvectorFormula pNumber, int pMsb, int pLsb) {
synchronized (sync) {
return delegate.extract(pNumber, pMsb, pLsb);
}
}
@Override
public BitvectorFormula extend(BitvectorFormula pNumber, int pExtensionBits, boolean pSigned) {
synchronized (sync) {
return delegate.extend(pNumber, pExtensionBits, pSigned);
}
}
@Override
public BooleanFormula distinct(List<BitvectorFormula> pBits) {
synchronized (sync) {
return delegate.distinct(pBits);
}
}
}
| 6,323 | 25.910638 | 97 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedBooleanFormulaManager.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Collection;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.BooleanFormulaManager;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.visitors.BooleanFormulaTransformationVisitor;
import org.sosy_lab.java_smt.api.visitors.BooleanFormulaVisitor;
import org.sosy_lab.java_smt.api.visitors.TraversalProcess;
class SynchronizedBooleanFormulaManager implements BooleanFormulaManager {
private final BooleanFormulaManager delegate;
private final SolverContext sync;
private final BooleanFormula tru;
private final BooleanFormula fls;
SynchronizedBooleanFormulaManager(BooleanFormulaManager pDelegate, SolverContext pSync) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
tru = delegate.makeTrue();
fls = delegate.makeFalse();
}
@Override
public BooleanFormula makeTrue() {
return tru;
}
@Override
public BooleanFormula makeFalse() {
return fls;
}
@Override
public BooleanFormula makeVariable(String pVar) {
synchronized (sync) {
return delegate.makeVariable(pVar);
}
}
@Override
public BooleanFormula equivalence(BooleanFormula pFormula1, BooleanFormula pFormula2) {
synchronized (sync) {
return delegate.equivalence(pFormula1, pFormula2);
}
}
@Override
public BooleanFormula implication(BooleanFormula pFormula1, BooleanFormula pFormula2) {
synchronized (sync) {
return delegate.implication(pFormula1, pFormula2);
}
}
@Override
public boolean isTrue(BooleanFormula pFormula) {
if (pFormula == tru) {
return true;
}
synchronized (sync) {
return delegate.isTrue(pFormula);
}
}
@Override
public boolean isFalse(BooleanFormula pFormula) {
if (pFormula == fls) {
return true;
}
synchronized (sync) {
return delegate.isFalse(pFormula);
}
}
@Override
public <T extends Formula> T ifThenElse(BooleanFormula pCond, T pF1, T pF2) {
synchronized (sync) {
return delegate.ifThenElse(pCond, pF1, pF2);
}
}
@Override
public BooleanFormula not(BooleanFormula pBits) {
synchronized (sync) {
return delegate.not(pBits);
}
}
@Override
public BooleanFormula and(BooleanFormula pBits1, BooleanFormula pBits2) {
synchronized (sync) {
return delegate.and(pBits1, pBits2);
}
}
@Override
public BooleanFormula and(Collection<BooleanFormula> pBits) {
synchronized (sync) {
return delegate.and(pBits);
}
}
@Override
public BooleanFormula and(BooleanFormula... pBits) {
synchronized (sync) {
return delegate.and(pBits);
}
}
@Override
public Collector<BooleanFormula, ?, BooleanFormula> toConjunction() {
return Collectors.collectingAndThen(Collectors.toList(), this::and);
}
@Override
public BooleanFormula or(BooleanFormula pBits1, BooleanFormula pBits2) {
synchronized (sync) {
return delegate.or(pBits1, pBits2);
}
}
@Override
public BooleanFormula or(Collection<BooleanFormula> pBits) {
synchronized (sync) {
return delegate.or(pBits);
}
}
@Override
public BooleanFormula or(BooleanFormula... pBits) {
synchronized (sync) {
return delegate.or(pBits);
}
}
@Override
public Collector<BooleanFormula, ?, BooleanFormula> toDisjunction() {
return Collectors.collectingAndThen(Collectors.toList(), this::or);
}
@Override
public BooleanFormula xor(BooleanFormula pBits1, BooleanFormula pBits2) {
synchronized (sync) {
return delegate.xor(pBits1, pBits2);
}
}
@Override
public <R> R visit(BooleanFormula pFormula, BooleanFormulaVisitor<R> pVisitor) {
synchronized (sync) {
return delegate.visit(pFormula, pVisitor);
}
}
@Override
public void visitRecursively(
BooleanFormula pF, BooleanFormulaVisitor<TraversalProcess> pRFormulaVisitor) {
synchronized (sync) {
delegate.visitRecursively(pF, pRFormulaVisitor);
}
}
@Override
public BooleanFormula transformRecursively(
BooleanFormula pF, BooleanFormulaTransformationVisitor pVisitor) {
synchronized (sync) {
return delegate.transformRecursively(pF, pVisitor);
}
}
@Override
public Set<BooleanFormula> toConjunctionArgs(BooleanFormula pF, boolean pFlatten) {
synchronized (sync) {
return delegate.toConjunctionArgs(pF, pFlatten);
}
}
@Override
public Set<BooleanFormula> toDisjunctionArgs(BooleanFormula pF, boolean pFlatten) {
synchronized (sync) {
return delegate.toDisjunctionArgs(pF, pFlatten);
}
}
}
| 5,124 | 24.497512 | 91 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedEnumerationFormulaManager.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Set;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.EnumerationFormula;
import org.sosy_lab.java_smt.api.EnumerationFormulaManager;
import org.sosy_lab.java_smt.api.FormulaType.EnumerationFormulaType;
import org.sosy_lab.java_smt.api.SolverContext;
public class SynchronizedEnumerationFormulaManager implements EnumerationFormulaManager {
private final EnumerationFormulaManager delegate;
private final SolverContext sync;
SynchronizedEnumerationFormulaManager(EnumerationFormulaManager pDelegate, SolverContext pSync) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
}
@Override
public EnumerationFormulaType declareEnumeration(String name, Set<String> elementNames) {
synchronized (sync) {
return delegate.declareEnumeration(name, elementNames);
}
}
@Override
public EnumerationFormula makeConstant(String pName, EnumerationFormulaType pType) {
synchronized (sync) {
return delegate.makeConstant(pName, pType);
}
}
@Override
public EnumerationFormula makeVariable(String pVar, EnumerationFormulaType pType) {
synchronized (sync) {
return delegate.makeVariable(pVar, pType);
}
}
@Override
public BooleanFormula equivalence(
EnumerationFormula pEnumeration1, EnumerationFormula pEnumeration2) {
synchronized (sync) {
return delegate.equivalence(pEnumeration1, pEnumeration2);
}
}
}
| 1,819 | 29.847458 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedFloatingPointFormulaManager.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import java.math.BigDecimal;
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.FloatingPointFormula;
import org.sosy_lab.java_smt.api.FloatingPointFormulaManager;
import org.sosy_lab.java_smt.api.FloatingPointRoundingMode;
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.SolverContext;
class SynchronizedFloatingPointFormulaManager implements FloatingPointFormulaManager {
private final FloatingPointFormulaManager delegate;
private final SolverContext sync;
SynchronizedFloatingPointFormulaManager(
FloatingPointFormulaManager pDelegate, SolverContext pSync) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
}
@Override
public FloatingPointFormula makeNumber(double pN, FloatingPointType pType) {
synchronized (sync) {
return delegate.makeNumber(pN, pType);
}
}
@Override
public FloatingPointFormula makeNumber(
double pN, FloatingPointType pType, FloatingPointRoundingMode pFloatingPointRoundingMode) {
synchronized (sync) {
return delegate.makeNumber(pN, pType, pFloatingPointRoundingMode);
}
}
@Override
public FloatingPointFormula makeNumber(BigDecimal pN, FloatingPointType pType) {
synchronized (sync) {
return delegate.makeNumber(pN, pType);
}
}
@Override
public FloatingPointFormula makeNumber(
BigDecimal pN,
FloatingPointType pType,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
synchronized (sync) {
return delegate.makeNumber(pN, pType, pFloatingPointRoundingMode);
}
}
@Override
public FloatingPointFormula makeNumber(String pN, FloatingPointType pType) {
synchronized (sync) {
return delegate.makeNumber(pN, pType);
}
}
@Override
public FloatingPointFormula makeNumber(
String pN, FloatingPointType pType, FloatingPointRoundingMode pFloatingPointRoundingMode) {
synchronized (sync) {
return delegate.makeNumber(pN, pType, pFloatingPointRoundingMode);
}
}
@Override
public FloatingPointFormula makeNumber(Rational pN, FloatingPointType pType) {
synchronized (sync) {
return delegate.makeNumber(pN, pType);
}
}
@Override
public FloatingPointFormula makeNumber(
Rational pN, FloatingPointType pType, FloatingPointRoundingMode pFloatingPointRoundingMode) {
synchronized (sync) {
return delegate.makeNumber(pN, pType, pFloatingPointRoundingMode);
}
}
@Override
public FloatingPointFormula makeVariable(String pVar, FloatingPointType pType) {
synchronized (sync) {
return delegate.makeVariable(pVar, pType);
}
}
@Override
public FloatingPointFormula makePlusInfinity(FloatingPointType pType) {
synchronized (sync) {
return delegate.makePlusInfinity(pType);
}
}
@Override
public FloatingPointFormula makeMinusInfinity(FloatingPointType pType) {
synchronized (sync) {
return delegate.makeMinusInfinity(pType);
}
}
@Override
public FloatingPointFormula makeNaN(FloatingPointType pType) {
synchronized (sync) {
return delegate.makeNaN(pType);
}
}
@Override
public <T extends Formula> T castTo(
FloatingPointFormula pNumber, boolean pSigned, FormulaType<T> pTargetType) {
synchronized (sync) {
return delegate.castTo(pNumber, pSigned, pTargetType);
}
}
@Override
public <T extends Formula> T castTo(
FloatingPointFormula pNumber,
boolean pSigned,
FormulaType<T> pTargetType,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
synchronized (sync) {
return delegate.castTo(pNumber, pSigned, pTargetType, pFloatingPointRoundingMode);
}
}
@Override
public FloatingPointFormula castFrom(
Formula pSource, boolean pSigned, FloatingPointType pTargetType) {
synchronized (sync) {
return delegate.castFrom(pSource, pSigned, pTargetType);
}
}
@Override
public FloatingPointFormula castFrom(
Formula pSource,
boolean pSigned,
FloatingPointType pTargetType,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
synchronized (sync) {
return delegate.castFrom(pSource, pSigned, pTargetType, pFloatingPointRoundingMode);
}
}
@Override
public FloatingPointFormula fromIeeeBitvector(
BitvectorFormula pNumber, FloatingPointType pTargetType) {
synchronized (sync) {
return delegate.fromIeeeBitvector(pNumber, pTargetType);
}
}
@Override
public BitvectorFormula toIeeeBitvector(FloatingPointFormula pNumber) {
synchronized (sync) {
return delegate.toIeeeBitvector(pNumber);
}
}
@Override
public FloatingPointFormula round(
FloatingPointFormula pFormula, FloatingPointRoundingMode pRoundingMode) {
synchronized (sync) {
return delegate.round(pFormula, pRoundingMode);
}
}
@Override
public FloatingPointFormula negate(FloatingPointFormula pNumber) {
synchronized (sync) {
return delegate.negate(pNumber);
}
}
@Override
public FloatingPointFormula abs(FloatingPointFormula pNumber) {
synchronized (sync) {
return delegate.abs(pNumber);
}
}
@Override
public FloatingPointFormula max(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
synchronized (sync) {
return delegate.max(pNumber1, pNumber2);
}
}
@Override
public FloatingPointFormula min(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
synchronized (sync) {
return delegate.min(pNumber1, pNumber2);
}
}
@Override
public FloatingPointFormula sqrt(FloatingPointFormula pNumber) {
synchronized (sync) {
return delegate.sqrt(pNumber);
}
}
@Override
public FloatingPointFormula sqrt(
FloatingPointFormula pNumber, FloatingPointRoundingMode pRoundingMode) {
synchronized (sync) {
return delegate.sqrt(pNumber, pRoundingMode);
}
}
@Override
public FloatingPointFormula add(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
synchronized (sync) {
return delegate.add(pNumber1, pNumber2);
}
}
@Override
public FloatingPointFormula add(
FloatingPointFormula pNumber1,
FloatingPointFormula pNumber2,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
synchronized (sync) {
return delegate.add(pNumber1, pNumber2, pFloatingPointRoundingMode);
}
}
@Override
public FloatingPointFormula subtract(
FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
synchronized (sync) {
return delegate.subtract(pNumber1, pNumber2);
}
}
@Override
public FloatingPointFormula subtract(
FloatingPointFormula pNumber1,
FloatingPointFormula pNumber2,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
synchronized (sync) {
return delegate.subtract(pNumber1, pNumber2, pFloatingPointRoundingMode);
}
}
@Override
public FloatingPointFormula divide(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
synchronized (sync) {
return delegate.divide(pNumber1, pNumber2);
}
}
@Override
public FloatingPointFormula divide(
FloatingPointFormula pNumber1,
FloatingPointFormula pNumber2,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
synchronized (sync) {
return delegate.divide(pNumber1, pNumber2, pFloatingPointRoundingMode);
}
}
@Override
public FloatingPointFormula multiply(
FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
synchronized (sync) {
return delegate.multiply(pNumber1, pNumber2);
}
}
@Override
public FloatingPointFormula multiply(
FloatingPointFormula pNumber1,
FloatingPointFormula pNumber2,
FloatingPointRoundingMode pFloatingPointRoundingMode) {
synchronized (sync) {
return delegate.multiply(pNumber1, pNumber2, pFloatingPointRoundingMode);
}
}
@Override
public BooleanFormula assignment(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
synchronized (sync) {
return delegate.assignment(pNumber1, pNumber2);
}
}
@Override
public BooleanFormula equalWithFPSemantics(
FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
synchronized (sync) {
return delegate.equalWithFPSemantics(pNumber1, pNumber2);
}
}
@Override
public BooleanFormula greaterThan(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
synchronized (sync) {
return delegate.greaterThan(pNumber1, pNumber2);
}
}
@Override
public BooleanFormula greaterOrEquals(
FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
synchronized (sync) {
return delegate.greaterOrEquals(pNumber1, pNumber2);
}
}
@Override
public BooleanFormula lessThan(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
synchronized (sync) {
return delegate.lessThan(pNumber1, pNumber2);
}
}
@Override
public BooleanFormula lessOrEquals(FloatingPointFormula pNumber1, FloatingPointFormula pNumber2) {
synchronized (sync) {
return delegate.lessOrEquals(pNumber1, pNumber2);
}
}
@Override
public BooleanFormula isNaN(FloatingPointFormula pNumber) {
synchronized (sync) {
return delegate.isNaN(pNumber);
}
}
@Override
public BooleanFormula isInfinity(FloatingPointFormula pNumber) {
synchronized (sync) {
return delegate.isInfinity(pNumber);
}
}
@Override
public BooleanFormula isZero(FloatingPointFormula pNumber) {
synchronized (sync) {
return delegate.isZero(pNumber);
}
}
@Override
public BooleanFormula isNormal(FloatingPointFormula pNumber) {
synchronized (sync) {
return delegate.isNormal(pNumber);
}
}
@Override
public BooleanFormula isSubnormal(FloatingPointFormula pNumber) {
synchronized (sync) {
return delegate.isSubnormal(pNumber);
}
}
@Override
public BooleanFormula isNegative(FloatingPointFormula pNumber) {
synchronized (sync) {
return delegate.isNegative(pNumber);
}
}
}
| 10,730 | 26.800518 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedFormulaManager.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.collect.ImmutableMap;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import org.sosy_lab.common.Appender;
import org.sosy_lab.common.Appenders;
import org.sosy_lab.java_smt.api.ArrayFormulaManager;
import org.sosy_lab.java_smt.api.BitvectorFormulaManager;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.BooleanFormulaManager;
import org.sosy_lab.java_smt.api.EnumerationFormulaManager;
import org.sosy_lab.java_smt.api.FloatingPointFormulaManager;
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.api.FunctionDeclaration;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.QuantifiedFormulaManager;
import org.sosy_lab.java_smt.api.RationalFormulaManager;
import org.sosy_lab.java_smt.api.SLFormulaManager;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.StringFormulaManager;
import org.sosy_lab.java_smt.api.Tactic;
import org.sosy_lab.java_smt.api.UFManager;
import org.sosy_lab.java_smt.api.visitors.FormulaTransformationVisitor;
import org.sosy_lab.java_smt.api.visitors.FormulaVisitor;
import org.sosy_lab.java_smt.api.visitors.TraversalProcess;
class SynchronizedFormulaManager implements FormulaManager {
private final FormulaManager delegate;
private final SolverContext sync;
protected SynchronizedFormulaManager(FormulaManager pDelegate, SolverContext pSync) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
}
@Override
public IntegerFormulaManager getIntegerFormulaManager() {
synchronized (sync) {
return new SynchronizedIntegerFormulaManager(delegate.getIntegerFormulaManager(), sync);
}
}
@Override
public RationalFormulaManager getRationalFormulaManager() {
synchronized (sync) {
return new SynchronizedRationalFormulaManager(delegate.getRationalFormulaManager(), sync);
}
}
@Override
public BooleanFormulaManager getBooleanFormulaManager() {
synchronized (sync) {
return new SynchronizedBooleanFormulaManager(delegate.getBooleanFormulaManager(), sync);
}
}
@Override
public ArrayFormulaManager getArrayFormulaManager() {
synchronized (sync) {
return new SynchronizedArrayFormulaManager(delegate.getArrayFormulaManager(), sync);
}
}
@Override
public BitvectorFormulaManager getBitvectorFormulaManager() {
synchronized (sync) {
return new SynchronizedBitvectorFormulaManager(delegate.getBitvectorFormulaManager(), sync);
}
}
@Override
public FloatingPointFormulaManager getFloatingPointFormulaManager() {
synchronized (sync) {
return new SynchronizedFloatingPointFormulaManager(
delegate.getFloatingPointFormulaManager(), sync);
}
}
@Override
public UFManager getUFManager() {
synchronized (sync) {
return new SynchronizedUFManager(delegate.getUFManager(), sync);
}
}
@Override
public SLFormulaManager getSLFormulaManager() {
synchronized (sync) {
return new SynchronizedSLFormulaManager(delegate.getSLFormulaManager(), sync);
}
}
@Override
public QuantifiedFormulaManager getQuantifiedFormulaManager() {
synchronized (sync) {
return new SynchronizedQuantifiedFormulaManager(delegate.getQuantifiedFormulaManager(), sync);
}
}
@Override
public StringFormulaManager getStringFormulaManager() {
synchronized (sync) {
return new SynchronizedStringFormulaManager(delegate.getStringFormulaManager(), sync);
}
}
@Override
public EnumerationFormulaManager getEnumerationFormulaManager() {
synchronized (sync) {
return new SynchronizedEnumerationFormulaManager(
delegate.getEnumerationFormulaManager(), sync);
}
}
@Override
public <T extends Formula> T makeVariable(FormulaType<T> pFormulaType, String pName) {
synchronized (sync) {
return delegate.makeVariable(pFormulaType, pName);
}
}
@Override
public <T extends Formula> T makeApplication(
FunctionDeclaration<T> pDeclaration, List<? extends Formula> pArgs) {
synchronized (sync) {
return delegate.makeApplication(pDeclaration, pArgs);
}
}
@Override
public <T extends Formula> T makeApplication(
FunctionDeclaration<T> pDeclaration, Formula... pArgs) {
synchronized (sync) {
return delegate.makeApplication(pDeclaration, pArgs);
}
}
@Override
public <T extends Formula> FormulaType<T> getFormulaType(T pFormula) {
synchronized (sync) {
return delegate.getFormulaType(pFormula);
}
}
@Override
public BooleanFormula parse(String pS) throws IllegalArgumentException {
synchronized (sync) {
return delegate.parse(pS);
}
}
@Override
public Appender dumpFormula(BooleanFormula pT) {
return new Appenders.AbstractAppender() {
@Override
public void appendTo(Appendable out) throws IOException {
String dump;
synchronized (sync) {
dump = delegate.dumpFormula(pT).toString(); // the work is done here
}
out.append(dump);
}
};
}
@Override
public BooleanFormula applyTactic(BooleanFormula pInput, Tactic pTactic)
throws InterruptedException {
synchronized (sync) {
return delegate.applyTactic(pInput, pTactic);
}
}
@Override
public <T extends Formula> T simplify(T pInput) throws InterruptedException {
synchronized (sync) {
return delegate.simplify(pInput);
}
}
@Override
public <R> R visit(Formula pF, FormulaVisitor<R> pFormulaVisitor) {
synchronized (sync) {
return delegate.visit(pF, pFormulaVisitor);
}
}
@Override
public void visitRecursively(Formula pF, FormulaVisitor<TraversalProcess> pFormulaVisitor) {
synchronized (sync) {
delegate.visitRecursively(pF, pFormulaVisitor);
}
}
@Override
public <T extends Formula> T transformRecursively(
T pF, FormulaTransformationVisitor pFormulaVisitor) {
synchronized (sync) {
return delegate.transformRecursively(pF, pFormulaVisitor);
}
}
@Override
public ImmutableMap<String, Formula> extractVariables(Formula pF) {
synchronized (sync) {
return delegate.extractVariables(pF);
}
}
@Override
public ImmutableMap<String, Formula> extractVariablesAndUFs(Formula pF) {
synchronized (sync) {
return delegate.extractVariablesAndUFs(pF);
}
}
@Override
public <T extends Formula> T substitute(
T pF, Map<? extends Formula, ? extends Formula> pFromToMapping) {
synchronized (sync) {
return delegate.substitute(pF, pFromToMapping);
}
}
@Override
public BooleanFormula translateFrom(BooleanFormula pFormula, FormulaManager pOtherContext) {
synchronized (sync) {
return delegate.translateFrom(pFormula, pOtherContext);
}
}
@Override
public boolean isValidName(String pVariableName) {
synchronized (sync) {
return delegate.isValidName(pVariableName);
}
}
@Override
public String escape(String pVariableName) {
synchronized (sync) {
return delegate.escape(pVariableName);
}
}
@Override
public String unescape(String pVariableName) {
synchronized (sync) {
return delegate.unescape(pVariableName);
}
}
}
| 7,767 | 27.985075 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedIntegerFormulaManager.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import java.math.BigInteger;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.SolverContext;
class SynchronizedIntegerFormulaManager
extends SynchronizedNumeralFormulaManager<IntegerFormula, IntegerFormula>
implements IntegerFormulaManager {
private final IntegerFormulaManager delegate;
SynchronizedIntegerFormulaManager(IntegerFormulaManager pDelegate, SolverContext pSync) {
super(pDelegate, pSync);
delegate = checkNotNull(pDelegate);
}
@Override
public BooleanFormula modularCongruence(
IntegerFormula pNumber1, IntegerFormula pNumber2, BigInteger pN) {
synchronized (sync) {
return delegate.modularCongruence(pNumber1, pNumber2, pN);
}
}
@Override
public BooleanFormula modularCongruence(
IntegerFormula pNumber1, IntegerFormula pNumber2, long pN) {
synchronized (sync) {
return delegate.modularCongruence(pNumber1, pNumber2, pN);
}
}
@Override
public IntegerFormula modulo(IntegerFormula pNumber1, IntegerFormula pNumber2) {
synchronized (sync) {
return delegate.modulo(pNumber1, pNumber2);
}
}
}
| 1,616 | 29.509434 | 91 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedInterpolatingProverEnvironment.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.delegate.synchronize;
import java.util.Collection;
import java.util.List;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverException;
class SynchronizedInterpolatingProverEnvironment<T> extends SynchronizedBasicProverEnvironment<T>
implements InterpolatingProverEnvironment<T> {
private final InterpolatingProverEnvironment<T> delegate;
SynchronizedInterpolatingProverEnvironment(
InterpolatingProverEnvironment<T> pDelegate, SolverContext pSync) {
super(pDelegate, pSync);
delegate = pDelegate;
}
@Override
public BooleanFormula getInterpolant(Collection<T> pFormulasOfA)
throws SolverException, InterruptedException {
synchronized (sync) {
return delegate.getInterpolant(pFormulasOfA);
}
}
@Override
public List<BooleanFormula> getSeqInterpolants(List<? extends Collection<T>> pPartitionedFormulas)
throws SolverException, InterruptedException {
synchronized (sync) {
return delegate.getSeqInterpolants(pPartitionedFormulas);
}
}
@Override
public List<BooleanFormula> getTreeInterpolants(
List<? extends Collection<T>> pPartitionedFormulas, int[] pStartOfSubTree)
throws SolverException, InterruptedException {
synchronized (sync) {
return delegate.getTreeInterpolants(pPartitionedFormulas, pStartOfSubTree);
}
}
}
| 1,754 | 31.5 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedInterpolatingProverEnvironmentWithContext.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Collection;
import java.util.List;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.FormulaManager;
import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverException;
class SynchronizedInterpolatingProverEnvironmentWithContext<T>
extends SynchronizedBasicProverEnvironmentWithContext<T>
implements InterpolatingProverEnvironment<T> {
private final InterpolatingProverEnvironment<T> delegate;
SynchronizedInterpolatingProverEnvironmentWithContext(
InterpolatingProverEnvironment<T> pDelegate,
SolverContext pSync,
FormulaManager pManager,
FormulaManager pOtherManager) {
super(pDelegate, pSync, pManager, pOtherManager);
delegate = checkNotNull(pDelegate);
}
@Override
public BooleanFormula getInterpolant(Collection<T> pFormulasOfA)
throws SolverException, InterruptedException {
return manager.translateFrom(delegate.getInterpolant(pFormulasOfA), otherManager);
}
@Override
public List<BooleanFormula> getSeqInterpolants(List<? extends Collection<T>> pPartitionedFormulas)
throws SolverException, InterruptedException {
return translate(delegate.getSeqInterpolants(pPartitionedFormulas), otherManager, manager);
}
@Override
public List<BooleanFormula> getTreeInterpolants(
List<? extends Collection<T>> pPartitionedFormulas, int[] pStartOfSubTree)
throws SolverException, InterruptedException {
return translate(
delegate.getTreeInterpolants(pPartitionedFormulas, pStartOfSubTree), otherManager, manager);
}
}
| 2,030 | 35.267857 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedModel.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.collect.ImmutableList;
import java.math.BigInteger;
import org.checkerframework.checker.nullness.qual.Nullable;
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.EnumerationFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.Model;
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.SolverContext;
import org.sosy_lab.java_smt.api.StringFormula;
class SynchronizedModel implements Model {
private final Model delegate;
private final SolverContext sync;
SynchronizedModel(Model pDelegate, SolverContext pSync) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
}
@Override
public <T extends Formula> @Nullable T eval(T pFormula) {
synchronized (sync) {
return delegate.eval(pFormula);
}
}
@Override
public @Nullable Object evaluate(Formula pF) {
synchronized (sync) {
return delegate.evaluate(pF);
}
}
@Override
public @Nullable BigInteger evaluate(IntegerFormula pF) {
synchronized (sync) {
return delegate.evaluate(pF);
}
}
@Override
public @Nullable Rational evaluate(RationalFormula pF) {
synchronized (sync) {
return delegate.evaluate(pF);
}
}
@Override
public @Nullable Boolean evaluate(BooleanFormula pF) {
synchronized (sync) {
return delegate.evaluate(pF);
}
}
@Override
public @Nullable BigInteger evaluate(BitvectorFormula pF) {
synchronized (sync) {
return delegate.evaluate(pF);
}
}
@Override
public @Nullable String evaluate(StringFormula pF) {
synchronized (sync) {
return delegate.evaluate(pF);
}
}
@Override
public @Nullable String evaluate(EnumerationFormula pF) {
synchronized (sync) {
return delegate.evaluate(pF);
}
}
@Override
public ImmutableList<ValueAssignment> asList() {
synchronized (sync) {
return delegate.asList();
}
}
@Override
public void close() {
synchronized (sync) {
delegate.close();
}
}
}
| 2,628 | 23.570093 | 69 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedModelWithContext.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.collect.ImmutableList;
import java.math.BigInteger;
import org.checkerframework.checker.nullness.qual.Nullable;
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.EnumerationFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.FormulaManager;
import org.sosy_lab.java_smt.api.Model;
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.SolverContext;
import org.sosy_lab.java_smt.api.StringFormula;
class SynchronizedModelWithContext implements Model {
private static final String UNSUPPORTED_OPERATION =
"translating non-boolean formulae is not supported";
private final Model delegate;
private final SolverContext sync;
private final FormulaManager manager;
private final FormulaManager otherManager;
SynchronizedModelWithContext(
Model pDelegate, SolverContext pSync, FormulaManager pManager, FormulaManager pOtherManager) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
manager = checkNotNull(pManager);
otherManager = checkNotNull(pOtherManager);
}
@Override
public <T extends Formula> @Nullable T eval(T pFormula) {
throw new UnsupportedOperationException(UNSUPPORTED_OPERATION);
}
@Override
public @Nullable Object evaluate(Formula pF) {
throw new UnsupportedOperationException(UNSUPPORTED_OPERATION);
}
@Override
public @Nullable BigInteger evaluate(IntegerFormula pF) {
throw new UnsupportedOperationException(UNSUPPORTED_OPERATION);
}
@Override
public @Nullable Rational evaluate(RationalFormula pF) {
throw new UnsupportedOperationException(UNSUPPORTED_OPERATION);
}
@Override
public @Nullable Boolean evaluate(BooleanFormula pF) {
BooleanFormula f;
synchronized (sync) {
f = otherManager.translateFrom(pF, manager);
}
return delegate.evaluate(f);
}
@Override
public @Nullable BigInteger evaluate(BitvectorFormula pF) {
throw new UnsupportedOperationException(UNSUPPORTED_OPERATION);
}
@Override
public @Nullable String evaluate(StringFormula pF) {
throw new UnsupportedOperationException(UNSUPPORTED_OPERATION);
}
@Override
public @Nullable String evaluate(EnumerationFormula pF) {
throw new UnsupportedOperationException(UNSUPPORTED_OPERATION);
}
@Override
public ImmutableList<ValueAssignment> asList() {
throw new UnsupportedOperationException(UNSUPPORTED_OPERATION);
// ImmutableList.Builder<ValueAssignment> builder = ImmutableList.builder();
// ImmutableList<ValueAssignment> lst = delegate.asList();
// synchronized (sync) {
// for (ValueAssignment va : lst) {
// if (va.getKey() instanceof BooleanFormula) {
// builder.add(
// new ValueAssignment(
// manager.translateFrom((BooleanFormula) va.getKey(), otherManager),
// manager.translateFrom((BooleanFormula) va.getValue(), otherManager),
// manager.translateFrom(va.getAssignmentAsFormula(), otherManager),
// va.getName(),
// va.getValue(),
// va.getArgumentsInterpretation()));
// } else {
// throw new UnsupportedOperationException(UNSUPPORTED_OPERATION);
// }
// }
// }
// return builder.build();
}
@Override
public void close() {
synchronized (sync) {
delegate.close();
}
}
}
| 3,884 | 31.107438 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedNumeralFormulaManager.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.List;
import org.sosy_lab.common.rationals.Rational;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.NumeralFormula;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.NumeralFormulaManager;
import org.sosy_lab.java_smt.api.SolverContext;
@SuppressWarnings("ClassTypeParameterName")
class SynchronizedNumeralFormulaManager<
ParamFormulaType extends NumeralFormula, ResultFormulaType extends NumeralFormula>
implements NumeralFormulaManager<ParamFormulaType, ResultFormulaType> {
private final NumeralFormulaManager<ParamFormulaType, ResultFormulaType> delegate;
final SolverContext sync;
SynchronizedNumeralFormulaManager(
NumeralFormulaManager<ParamFormulaType, ResultFormulaType> pDelegate, SolverContext pSync) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
}
@Override
public ResultFormulaType makeNumber(long pNumber) {
synchronized (sync) {
return delegate.makeNumber(pNumber);
}
}
@Override
public ResultFormulaType makeNumber(BigInteger pNumber) {
synchronized (sync) {
return delegate.makeNumber(pNumber);
}
}
@Override
public ResultFormulaType makeNumber(double pNumber) {
synchronized (sync) {
return delegate.makeNumber(pNumber);
}
}
@Override
public ResultFormulaType makeNumber(BigDecimal pNumber) {
synchronized (sync) {
return delegate.makeNumber(pNumber);
}
}
@Override
public ResultFormulaType makeNumber(String pI) {
synchronized (sync) {
return delegate.makeNumber(pI);
}
}
@Override
public ResultFormulaType makeNumber(Rational pRational) {
synchronized (sync) {
return delegate.makeNumber(pRational);
}
}
@Override
public ResultFormulaType makeVariable(String pVar) {
synchronized (sync) {
return delegate.makeVariable(pVar);
}
}
@Override
public FormulaType<ResultFormulaType> getFormulaType() {
synchronized (sync) {
return delegate.getFormulaType();
}
}
@Override
public ResultFormulaType negate(ParamFormulaType pNumber) {
synchronized (sync) {
return delegate.negate(pNumber);
}
}
@Override
public ResultFormulaType add(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
synchronized (sync) {
return delegate.add(pNumber1, pNumber2);
}
}
@Override
public ResultFormulaType sum(List<ParamFormulaType> pOperands) {
synchronized (sync) {
return delegate.sum(pOperands);
}
}
@Override
public ResultFormulaType subtract(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
synchronized (sync) {
return delegate.subtract(pNumber1, pNumber2);
}
}
@Override
public ResultFormulaType divide(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
synchronized (sync) {
return delegate.divide(pNumber1, pNumber2);
}
}
@Override
public ResultFormulaType multiply(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
synchronized (sync) {
return delegate.multiply(pNumber1, pNumber2);
}
}
@Override
public BooleanFormula equal(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
synchronized (sync) {
return delegate.equal(pNumber1, pNumber2);
}
}
@Override
public BooleanFormula distinct(List<ParamFormulaType> pNumbers) {
synchronized (sync) {
return delegate.distinct(pNumbers);
}
}
@Override
public BooleanFormula greaterThan(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
synchronized (sync) {
return delegate.greaterThan(pNumber1, pNumber2);
}
}
@Override
public BooleanFormula greaterOrEquals(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
synchronized (sync) {
return delegate.greaterOrEquals(pNumber1, pNumber2);
}
}
@Override
public BooleanFormula lessThan(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
synchronized (sync) {
return delegate.lessThan(pNumber1, pNumber2);
}
}
@Override
public BooleanFormula lessOrEquals(ParamFormulaType pNumber1, ParamFormulaType pNumber2) {
synchronized (sync) {
return delegate.lessOrEquals(pNumber1, pNumber2);
}
}
@Override
public IntegerFormula floor(ParamFormulaType pNumber) {
synchronized (sync) {
return delegate.floor(pNumber);
}
}
}
| 4,903 | 25.508108 | 98 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedOptimizationProverEnvironment.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.delegate.synchronize;
import java.util.Optional;
import org.sosy_lab.common.rationals.Rational;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.OptimizationProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverException;
class SynchronizedOptimizationProverEnvironment extends SynchronizedBasicProverEnvironment<Void>
implements OptimizationProverEnvironment {
private final OptimizationProverEnvironment delegate;
SynchronizedOptimizationProverEnvironment(
OptimizationProverEnvironment pDelegate, SolverContext pSync) {
super(pDelegate, pSync);
delegate = pDelegate;
}
@Override
public int maximize(Formula pObjective) {
synchronized (sync) {
return delegate.maximize(pObjective);
}
}
@Override
public int minimize(Formula pObjective) {
synchronized (sync) {
return delegate.minimize(pObjective);
}
}
@Override
public OptStatus check() throws InterruptedException, SolverException {
synchronized (sync) {
return delegate.check();
}
}
@Override
public Optional<Rational> upper(int pHandle, Rational pEpsilon) {
synchronized (sync) {
return delegate.upper(pHandle, pEpsilon);
}
}
@Override
public Optional<Rational> lower(int pHandle, Rational pEpsilon) {
synchronized (sync) {
return delegate.lower(pHandle, pEpsilon);
}
}
}
| 1,708 | 25.703125 | 96 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedProverEnvironment.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.delegate.synchronize;
import org.sosy_lab.java_smt.api.BasicProverEnvironment;
import org.sosy_lab.java_smt.api.ProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext;
class SynchronizedProverEnvironment extends SynchronizedBasicProverEnvironment<Void>
implements ProverEnvironment {
SynchronizedProverEnvironment(BasicProverEnvironment<Void> pDelegate, SolverContext pSync) {
super(pDelegate, pSync);
}
}
| 702 | 30.954545 | 94 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedProverEnvironmentWithContext.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.delegate.synchronize;
import org.sosy_lab.java_smt.api.FormulaManager;
import org.sosy_lab.java_smt.api.ProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext;
class SynchronizedProverEnvironmentWithContext
extends SynchronizedBasicProverEnvironmentWithContext<Void> implements ProverEnvironment {
SynchronizedProverEnvironmentWithContext(
ProverEnvironment pDelegate,
SolverContext pSync,
FormulaManager pManager,
FormulaManager pOtherManager) {
super(pDelegate, pSync, pManager, pOtherManager);
}
}
| 821 | 30.615385 | 94 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedQuantifiedFormulaManager.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.List;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.QuantifiedFormulaManager;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverException;
class SynchronizedQuantifiedFormulaManager implements QuantifiedFormulaManager {
private final QuantifiedFormulaManager delegate;
private final SolverContext sync;
SynchronizedQuantifiedFormulaManager(QuantifiedFormulaManager pDelegate, SolverContext pSync) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
}
@Override
public BooleanFormula mkQuantifier(
Quantifier pQ, List<? extends Formula> pVariables, BooleanFormula pBody) {
synchronized (sync) {
return delegate.mkQuantifier(pQ, pVariables, pBody);
}
}
@Override
public BooleanFormula eliminateQuantifiers(BooleanFormula pF)
throws InterruptedException, SolverException {
synchronized (sync) {
return delegate.eliminateQuantifiers(pF);
}
}
}
| 1,418 | 29.847826 | 97 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedRationalFormulaManager.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.delegate.synchronize;
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;
import org.sosy_lab.java_smt.api.SolverContext;
class SynchronizedRationalFormulaManager
extends SynchronizedNumeralFormulaManager<NumeralFormula, RationalFormula>
implements RationalFormulaManager {
SynchronizedRationalFormulaManager(RationalFormulaManager pDelegate, SolverContext pSync) {
super(pDelegate, pSync);
}
}
| 803 | 32.5 | 93 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedSLFormulaManager.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
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.SLFormulaManager;
import org.sosy_lab.java_smt.api.SolverContext;
@SuppressWarnings({"ClassTypeParameterName", "MethodTypeParameterName"})
class SynchronizedSLFormulaManager implements SLFormulaManager {
private final SLFormulaManager delegate;
private final SolverContext sync;
SynchronizedSLFormulaManager(SLFormulaManager pDelegate, SolverContext pSync) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
}
@Override
public BooleanFormula makeStar(BooleanFormula pF1, BooleanFormula pF2) {
synchronized (sync) {
return delegate.makeStar(pF1, pF2);
}
}
@Override
public <AF extends Formula, VF extends Formula> BooleanFormula makePointsTo(AF pPtr, VF pTo) {
synchronized (sync) {
return delegate.makePointsTo(pPtr, pTo);
}
}
@Override
public BooleanFormula makeMagicWand(BooleanFormula pF1, BooleanFormula pF2) {
synchronized (sync) {
return delegate.makeMagicWand(pF1, pF2);
}
}
@Override
public <
AF extends Formula,
VF extends Formula,
AT extends FormulaType<AF>,
VT extends FormulaType<VF>>
BooleanFormula makeEmptyHeap(AT pAdressType, VT pValueType) {
synchronized (sync) {
return delegate.makeEmptyHeap(pAdressType, pValueType);
}
}
@Override
public <AF extends Formula, AT extends FormulaType<AF>> AF makeNilElement(AT pAdressType) {
synchronized (sync) {
return delegate.makeNilElement(pAdressType);
}
}
}
| 2,030 | 28.014286 | 96 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedSolverContext.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
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.log.LogManager;
import org.sosy_lab.java_smt.SolverContextFactory;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
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.api.SolverContext;
@Options(prefix = "solver.synchronized")
public class SynchronizedSolverContext implements SolverContext {
@Option(
secure = true,
description =
"Use provers from a seperate context to solve queries. "
+ "This allows more parallelity when solving larger queries.")
private boolean useSeperateProvers = false;
private final SolverContext delegate;
private final SolverContext sync;
private final Configuration config;
private final LogManager logger;
private final ShutdownNotifier shutdownNotifier;
public SynchronizedSolverContext(
Configuration pConfig,
LogManager pLogger,
ShutdownNotifier pShutdownNotifier,
SolverContext pDelegate)
throws InvalidConfigurationException {
pConfig.inject(this, SynchronizedSolverContext.class);
delegate = checkNotNull(pDelegate);
sync = delegate;
config = pConfig;
logger = pLogger;
shutdownNotifier = pShutdownNotifier;
}
@SuppressWarnings("resource")
private SolverContext createOtherContext() {
SolverContext otherContext;
try {
otherContext =
SolverContextFactory.createSolverContext(
config, logger, shutdownNotifier, delegate.getSolverName());
} catch (InvalidConfigurationException e) {
throw new AssertionError("should not happen, current context was already created before.");
}
Preconditions.checkState(
otherContext instanceof SynchronizedSolverContext,
"same config implies same nesting of solver contexts.");
return ((SynchronizedSolverContext) otherContext).delegate;
}
@Override
public FormulaManager getFormulaManager() {
return new SynchronizedFormulaManager(delegate.getFormulaManager(), delegate);
}
@SuppressWarnings("resource")
@Override
public ProverEnvironment newProverEnvironment(ProverOptions... pOptions) {
synchronized (sync) {
if (useSeperateProvers) {
SolverContext otherContext = createOtherContext();
return new SynchronizedProverEnvironmentWithContext(
otherContext.newProverEnvironment(pOptions),
sync,
delegate.getFormulaManager(),
otherContext.getFormulaManager());
} else {
return new SynchronizedProverEnvironment(delegate.newProverEnvironment(pOptions), delegate);
}
}
}
@SuppressWarnings("resource")
@Override
public InterpolatingProverEnvironment<?> newProverEnvironmentWithInterpolation(
ProverOptions... pOptions) {
synchronized (sync) {
if (useSeperateProvers) {
SolverContext otherContext = createOtherContext();
return new SynchronizedInterpolatingProverEnvironmentWithContext<>(
otherContext.newProverEnvironmentWithInterpolation(pOptions),
sync,
delegate.getFormulaManager(),
otherContext.getFormulaManager());
} else {
return new SynchronizedInterpolatingProverEnvironment<>(
delegate.newProverEnvironmentWithInterpolation(pOptions), delegate);
}
}
}
@SuppressWarnings("resource")
@Override
public OptimizationProverEnvironment newOptimizationProverEnvironment(ProverOptions... pOptions) {
synchronized (sync) {
// seperate prover environment not available, because we can not translate arbitrary formulae.
// if (useSeperateProvers) { }
return new SynchronizedOptimizationProverEnvironment(
delegate.newOptimizationProverEnvironment(pOptions), delegate);
}
}
@Override
public String getVersion() {
synchronized (sync) {
return delegate.getVersion();
}
}
@Override
public Solvers getSolverName() {
synchronized (sync) {
return delegate.getSolverName();
}
}
@Override
public ImmutableMap<String, String> getStatistics() {
synchronized (sync) {
return delegate.getStatistics();
}
}
@Override
public void close() {
synchronized (sync) {
delegate.close();
}
}
}
| 5,165 | 32.329032 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedStringFormulaManager.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 Alejandro Serrano Mena
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.List;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.NumeralFormula;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.RegexFormula;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.StringFormula;
import org.sosy_lab.java_smt.api.StringFormulaManager;
class SynchronizedStringFormulaManager implements StringFormulaManager {
private final StringFormulaManager delegate;
private final SolverContext sync;
SynchronizedStringFormulaManager(StringFormulaManager pDelegate, SolverContext pSync) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
}
@Override
public StringFormula makeString(String value) {
synchronized (sync) {
return delegate.makeString(value);
}
}
@Override
public StringFormula makeVariable(String pVar) {
synchronized (sync) {
return delegate.makeVariable(pVar);
}
}
@Override
public BooleanFormula equal(StringFormula str1, StringFormula str2) {
synchronized (sync) {
return delegate.equal(str1, str2);
}
}
@Override
public BooleanFormula greaterThan(StringFormula str1, StringFormula str2) {
synchronized (sync) {
return delegate.greaterThan(str1, str2);
}
}
@Override
public BooleanFormula greaterOrEquals(StringFormula str1, StringFormula str2) {
synchronized (sync) {
return delegate.greaterOrEquals(str1, str2);
}
}
@Override
public BooleanFormula lessThan(StringFormula str1, StringFormula str2) {
synchronized (sync) {
return delegate.lessThan(str1, str2);
}
}
@Override
public BooleanFormula lessOrEquals(StringFormula str1, StringFormula str2) {
synchronized (sync) {
return delegate.lessOrEquals(str1, str2);
}
}
@Override
public NumeralFormula.IntegerFormula length(StringFormula str) {
synchronized (sync) {
return delegate.length(str);
}
}
@Override
public StringFormula concat(List<StringFormula> parts) {
synchronized (sync) {
return delegate.concat(parts);
}
}
@Override
public BooleanFormula prefix(StringFormula str1, StringFormula str2) {
synchronized (sync) {
return delegate.prefix(str1, str2);
}
}
@Override
public BooleanFormula suffix(StringFormula str1, StringFormula str2) {
synchronized (sync) {
return delegate.suffix(str1, str2);
}
}
@Override
public BooleanFormula contains(StringFormula str, StringFormula part) {
synchronized (sync) {
return delegate.contains(str, part);
}
}
@Override
public IntegerFormula indexOf(StringFormula str, StringFormula part, IntegerFormula startIndex) {
synchronized (sync) {
return delegate.indexOf(str, part, startIndex);
}
}
@Override
public StringFormula charAt(StringFormula str, IntegerFormula index) {
synchronized (sync) {
return delegate.charAt(str, index);
}
}
@Override
public StringFormula substring(StringFormula str, IntegerFormula index, IntegerFormula length) {
synchronized (sync) {
return delegate.substring(str, index, length);
}
}
@Override
public StringFormula replace(
StringFormula fullStr, StringFormula target, StringFormula replacement) {
synchronized (sync) {
return delegate.replace(fullStr, target, replacement);
}
}
@Override
public StringFormula replaceAll(
StringFormula fullStr, StringFormula target, StringFormula replacement) {
synchronized (sync) {
return delegate.replaceAll(fullStr, target, replacement);
}
}
@Override
public BooleanFormula in(StringFormula str, RegexFormula regex) {
synchronized (sync) {
return delegate.in(str, regex);
}
}
@Override
public RegexFormula makeRegex(String value) {
synchronized (sync) {
return delegate.makeRegex(value);
}
}
@Override
public RegexFormula none() {
synchronized (sync) {
return delegate.none();
}
}
@Override
public RegexFormula all() {
synchronized (sync) {
return delegate.all();
}
}
@Override
public RegexFormula allChar() {
synchronized (sync) {
return delegate.allChar();
}
}
@Override
public RegexFormula range(StringFormula start, StringFormula end) {
synchronized (sync) {
return delegate.range(start, end);
}
}
@Override
public RegexFormula concatRegex(List<RegexFormula> parts) {
synchronized (sync) {
return delegate.concatRegex(parts);
}
}
@Override
public RegexFormula union(RegexFormula regex1, RegexFormula regex2) {
synchronized (sync) {
return delegate.union(regex1, regex2);
}
}
@Override
public RegexFormula intersection(RegexFormula regex1, RegexFormula regex2) {
synchronized (sync) {
return delegate.intersection(regex1, regex2);
}
}
@Override
public RegexFormula closure(RegexFormula regex) {
synchronized (sync) {
return delegate.closure(regex);
}
}
@Override
public RegexFormula complement(RegexFormula regex) {
synchronized (sync) {
return delegate.complement(regex);
}
}
@Override
public RegexFormula difference(RegexFormula regex1, RegexFormula regex2) {
synchronized (sync) {
return delegate.difference(regex1, regex2);
}
}
@Override
public RegexFormula cross(RegexFormula regex) {
synchronized (sync) {
return delegate.cross(regex);
}
}
@Override
public RegexFormula optional(RegexFormula regex) {
synchronized (sync) {
return delegate.optional(regex);
}
}
@Override
public RegexFormula times(RegexFormula regex, int repetitions) {
synchronized (sync) {
return delegate.times(regex, repetitions);
}
}
@Override
public IntegerFormula toIntegerFormula(StringFormula str) {
synchronized (sync) {
return delegate.toIntegerFormula(str);
}
}
@Override
public StringFormula toStringFormula(IntegerFormula number) {
synchronized (sync) {
return delegate.toStringFormula(number);
}
}
}
| 6,508 | 22.930147 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedUFManager.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.delegate.synchronize;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.List;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.FunctionDeclaration;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.UFManager;
class SynchronizedUFManager implements UFManager {
private final UFManager delegate;
private final SolverContext sync;
SynchronizedUFManager(UFManager pDelegate, SolverContext pSync) {
delegate = checkNotNull(pDelegate);
sync = checkNotNull(pSync);
}
@Override
public <T extends Formula> FunctionDeclaration<T> declareUF(
String pName, FormulaType<T> pReturnType, List<FormulaType<?>> pArgs) {
synchronized (sync) {
return delegate.declareUF(pName, pReturnType, pArgs);
}
}
@Override
public <T extends Formula> FunctionDeclaration<T> declareUF(
String pName, FormulaType<T> pReturnType, FormulaType<?>... pArgs) {
synchronized (sync) {
return delegate.declareUF(pName, pReturnType, pArgs);
}
}
@Override
public <T extends Formula> T callUF(
FunctionDeclaration<T> pFuncType, List<? extends Formula> pArgs) {
synchronized (sync) {
return delegate.callUF(pFuncType, pArgs);
}
}
@Override
public <T extends Formula> T callUF(FunctionDeclaration<T> pFuncType, Formula... pArgs) {
synchronized (sync) {
return delegate.callUF(pFuncType, pArgs);
}
}
@Override
public <T extends Formula> T declareAndCallUF(
String pName, FormulaType<T> pReturnType, List<Formula> pArgs) {
synchronized (sync) {
return delegate.declareAndCallUF(pName, pReturnType, pArgs);
}
}
@Override
public <T extends Formula> T declareAndCallUF(
String pName, FormulaType<T> pReturnType, Formula... pArgs) {
synchronized (sync) {
return delegate.declareAndCallUF(pName, pReturnType, pArgs);
}
}
}
| 2,252 | 28.25974 | 91 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/delegate/synchronize/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
/**
* The classes of this package wrap the whole solver context and all corresponding proving
* environment and synchronize all accesses to it.
*
* <p>This allows us to use a plain sequential solver in a concurrent context, i.e., we can create
* formulae and solve queries from multiple interleaving threads without any synchronization from
* the user.
*/
@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.delegate.synchronize;
| 879 | 39 | 98 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/example/AllSatExample.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: Unlicense OR Apache-2.0 OR MIT
package org.sosy_lab.java_smt.example;
import static org.sosy_lab.java_smt.SolverContextFactory.Solvers.BOOLECTOR;
import static org.sosy_lab.java_smt.SolverContextFactory.Solvers.CVC4;
import static org.sosy_lab.java_smt.SolverContextFactory.Solvers.MATHSAT5;
import static org.sosy_lab.java_smt.SolverContextFactory.Solvers.PRINCESS;
import static org.sosy_lab.java_smt.SolverContextFactory.Solvers.SMTINTERPOL;
import static org.sosy_lab.java_smt.SolverContextFactory.Solvers.YICES2;
import static org.sosy_lab.java_smt.SolverContextFactory.Solvers.Z3;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
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.log.BasicLogManager;
import org.sosy_lab.common.log.LogManager;
import org.sosy_lab.java_smt.SolverContextFactory;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
import org.sosy_lab.java_smt.api.BasicProverEnvironment.AllSatCallback;
import org.sosy_lab.java_smt.api.BitvectorFormula;
import org.sosy_lab.java_smt.api.BitvectorFormulaManager;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.BooleanFormulaManager;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.Model;
import org.sosy_lab.java_smt.api.Model.ValueAssignment;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.ProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
/**
* This example shows different ways to get all satisfiable models for a given set of constraints.
*/
@SuppressWarnings("unused")
public class AllSatExample {
private static final ImmutableSet<Solvers> SOLVERS_WITH_INTEGERS =
ImmutableSet.of(MATHSAT5, SMTINTERPOL, Z3, PRINCESS, CVC4, YICES2);
private static final ImmutableSet<Solvers> SOLVERS_WITH_BITVECTORS =
ImmutableSet.of(MATHSAT5, Z3, PRINCESS, BOOLECTOR, CVC4);
private BooleanFormulaManager bfmgr;
private IntegerFormulaManager ifmgr;
private BitvectorFormulaManager bvfmgr;
private final ProverEnvironment prover;
private final SolverContext context;
public static void main(String... args)
throws InvalidConfigurationException, SolverException, InterruptedException {
Configuration config = Configuration.defaultConfiguration();
LogManager logger = BasicLogManager.create(config);
ShutdownNotifier notifier = ShutdownNotifier.createDummy();
for (Solvers solver : Solvers.values()) {
try (SolverContext context =
SolverContextFactory.createSolverContext(config, logger, notifier, solver);
ProverEnvironment prover =
context.newProverEnvironment(
ProverOptions.GENERATE_MODELS, ProverOptions.GENERATE_ALL_SAT)) {
logger.log(Level.WARNING, "Using solver " + solver + " in version " + context.getVersion());
AllSatExample ase = new AllSatExample(context, prover);
prover.push();
logger.log(Level.INFO, ase.allSatBooleans1());
prover.pop();
prover.push();
logger.log(Level.INFO, ase.allSatBooleans2());
prover.pop();
if (SOLVERS_WITH_INTEGERS.contains(solver)) {
prover.push();
logger.log(Level.INFO, ase.allSatIntegers());
prover.pop();
prover.push();
logger.log(Level.INFO, ase.allSatIntegers2());
prover.pop();
}
if (SOLVERS_WITH_BITVECTORS.contains(solver)) {
prover.push();
logger.log(Level.INFO, ase.allSatBitvectors());
prover.pop();
}
} catch (InvalidConfigurationException | UnsatisfiedLinkError e) {
// on some machines we support only some solvers,
// thus we can ignore these errors.
logger.logUserException(Level.INFO, e, "Solver " + solver + " is not available.");
} catch (UnsupportedOperationException e) {
logger.logUserException(Level.INFO, e, e.getMessage());
}
}
}
public AllSatExample(SolverContext pContext, ProverEnvironment pProver) {
prover = pProver;
context = pContext;
}
/** For boolean symbols we can directly use the method {@link ProverEnvironment#allSat}. */
private List<List<BooleanFormula>> allSatBooleans1()
throws InterruptedException, SolverException {
bfmgr = context.getFormulaManager().getBooleanFormulaManager();
// formula (p --> q) with 3 models
BooleanFormula p = bfmgr.makeVariable("p");
BooleanFormula q = bfmgr.makeVariable("q");
prover.addConstraint(bfmgr.implication(p, q));
return prover.allSat(
new AllSatCallback<>() {
private final List<List<BooleanFormula>> models = new ArrayList<>();
@Override
public void apply(List<BooleanFormula> pModel) {
models.add(pModel);
}
@Override
public List<List<BooleanFormula>> getResult() {
return models;
}
},
ImmutableList.of(q, p));
}
/** For boolean symbols we can also ask the model directly for evaluations of symbols. */
private List<List<ValueAssignment>> allSatBooleans2()
throws InterruptedException, SolverException {
bfmgr = context.getFormulaManager().getBooleanFormulaManager();
// formula (p --> q) with 3 models
BooleanFormula p = bfmgr.makeVariable("p");
BooleanFormula q = bfmgr.makeVariable("q");
prover.addConstraint(bfmgr.implication(p, q));
List<List<ValueAssignment>> models = new ArrayList<>();
// loop over all possible models
while (!prover.isUnsat()) {
models.add(prover.getModelAssignments());
try (Model model = prover.getModel()) {
List<BooleanFormula> assignments = new ArrayList<>();
Boolean valueQ = model.evaluate(q);
// an unbounded result is null
if (valueQ != null) {
assignments.add(bfmgr.equivalence(q, bfmgr.makeBoolean(valueQ)));
}
Boolean valueP = model.evaluate(p);
// an unbounded result is null
if (valueP != null) {
assignments.add(bfmgr.equivalence(p, bfmgr.makeBoolean(valueP)));
}
// prevent next model from using the same assignment as a previous model
prover.addConstraint(bfmgr.not(bfmgr.and(assignments)));
}
}
return models;
}
/**
* For integer formulas, we can implement the allsat-loop and collect all models when iterating.
*/
private List<List<ValueAssignment>> allSatIntegers()
throws InterruptedException, SolverException {
bfmgr = context.getFormulaManager().getBooleanFormulaManager();
ifmgr = context.getFormulaManager().getIntegerFormulaManager();
// formula ((1 <= a <= 10) && (1 <= b <= 10) && (a >= 2 * b)) with 25 models
IntegerFormula a = ifmgr.makeVariable("a");
IntegerFormula b = ifmgr.makeVariable("b");
prover.addConstraint(ifmgr.lessOrEquals(num(1), a));
prover.addConstraint(ifmgr.lessOrEquals(a, num(10)));
prover.addConstraint(ifmgr.lessOrEquals(num(1), b));
prover.addConstraint(ifmgr.lessOrEquals(b, num(10)));
prover.addConstraint(ifmgr.greaterOrEquals(a, ifmgr.multiply(num(2), b)));
List<List<ValueAssignment>> models = new ArrayList<>();
// loop over all possible models for "1<=a<=10 AND 1<=b<=10 AND a==2*b"
while (!prover.isUnsat()) {
models.add(prover.getModelAssignments());
try (Model model = prover.getModel()) {
// convert model into formula, assuming we know all symbols and know they are integers
BooleanFormula modelAsFormula =
bfmgr.and(
ifmgr.equal(a, num(model.evaluate(a))), ifmgr.equal(b, num(model.evaluate(b))));
// prevent next model from using the same assignment as a previous model
prover.addConstraint(bfmgr.not(modelAsFormula));
}
}
return models;
}
/**
* For integer formulas, we can implement the allsat-loop and collect all models when iterating.
*/
private List<List<ValueAssignment>> allSatIntegers2()
throws InterruptedException, SolverException {
bfmgr = context.getFormulaManager().getBooleanFormulaManager();
ifmgr = context.getFormulaManager().getIntegerFormulaManager();
// formula ((1 <= a <= 3) && (0 == b) && (p == q)) with 6 models
IntegerFormula a = ifmgr.makeVariable("a");
IntegerFormula b = ifmgr.makeVariable("b");
BooleanFormula p = bfmgr.makeVariable("p");
BooleanFormula q = bfmgr.makeVariable("q");
prover.addConstraint(ifmgr.lessOrEquals(num(1), a));
prover.addConstraint(ifmgr.equal(num(0), b));
prover.addConstraint(ifmgr.lessOrEquals(a, num(3)));
prover.addConstraint(bfmgr.equivalence(p, q));
List<List<ValueAssignment>> models = new ArrayList<>();
// loop over all possible models for "1<=a<=3 AND p=q"
while (!prover.isUnsat()) {
final ImmutableList<ValueAssignment> modelAssignments = prover.getModelAssignments();
models.add(modelAssignments);
final List<BooleanFormula> modelAssignmentsAsFormulas = new ArrayList<>();
for (ValueAssignment va : modelAssignments) {
modelAssignmentsAsFormulas.add(va.getAssignmentAsFormula());
}
// prevent next model from using the same assignment as a previous model
prover.addConstraint(bfmgr.not(bfmgr.and(modelAssignmentsAsFormulas)));
}
return models;
}
private IntegerFormula num(int number) {
return ifmgr.makeNumber(number);
}
private IntegerFormula num(BigInteger number) {
return ifmgr.makeNumber(number);
}
/**
* For bitvector formulas, we can implement the allsat-loop and collect all models when iterating.
*/
private List<List<ValueAssignment>> allSatBitvectors()
throws InterruptedException, SolverException {
bfmgr = context.getFormulaManager().getBooleanFormulaManager();
bvfmgr = context.getFormulaManager().getBitvectorFormulaManager();
// formula ((1 <= a <= 3) && (0 == b) && (p == q)) with 6 models
final int bitsize = 4;
BitvectorFormula a = bvfmgr.makeVariable(bitsize, "c");
BitvectorFormula b = bvfmgr.makeVariable(bitsize, "d");
BooleanFormula p = bfmgr.makeVariable("r");
BooleanFormula q = bfmgr.makeVariable("s");
prover.addConstraint(bvfmgr.lessOrEquals(bv(bitsize, 1), a, true));
prover.addConstraint(bvfmgr.equal(bv(bitsize, 0), b));
prover.addConstraint(bvfmgr.lessOrEquals(a, bv(bitsize, 3), true));
prover.addConstraint(bfmgr.equivalence(p, q));
List<List<ValueAssignment>> models = new ArrayList<>();
// loop over all possible models for "1<=a<=3 AND p=q"
while (!prover.isUnsat()) {
final ImmutableList<ValueAssignment> modelAssignments = prover.getModelAssignments();
models.add(modelAssignments);
final List<BooleanFormula> modelAssignmentsAsFormulas = new ArrayList<>();
for (ValueAssignment va : modelAssignments) {
modelAssignmentsAsFormulas.add(va.getAssignmentAsFormula());
}
// prevent next model from using the same assignment as a previous model
prover.addConstraint(bfmgr.not(bfmgr.and(modelAssignmentsAsFormulas)));
}
return models;
}
private BitvectorFormula bv(int bitsize, int number) {
return bvfmgr.makeBitvector(bitsize, number);
}
}
| 11,931 | 37 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/example/FormulaClassifier.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: Unlicense OR Apache-2.0 OR MIT
package org.sosy_lab.java_smt.example;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
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.EnumSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.logging.Level;
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.log.BasicLogManager;
import org.sosy_lab.common.log.LogManager;
import org.sosy_lab.java_smt.SolverContextFactory;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
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.api.FunctionDeclaration;
import org.sosy_lab.java_smt.api.FunctionDeclarationKind;
import org.sosy_lab.java_smt.api.QuantifiedFormulaManager.Quantifier;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverException;
import org.sosy_lab.java_smt.api.visitors.DefaultBooleanFormulaVisitor;
import org.sosy_lab.java_smt.api.visitors.FormulaVisitor;
import org.sosy_lab.java_smt.api.visitors.TraversalProcess;
/**
* This program parses user-given formulas and prints out the (minimal) matching theory for them.
*
* <p>Warning: This is a prototype and not intended for larger usage.
*/
@SuppressWarnings("unused")
public class FormulaClassifier {
private final FormulaManager mgr;
private final SolverContext context;
private final Classifier v = new Classifier();
private int levelLinearArithmetic = 0;
public static void main(String... args)
throws InvalidConfigurationException, SolverException, InterruptedException, IOException {
if (args.length == 0) {
help();
}
Solvers solver = Solvers.MATHSAT5;
Path path = null;
for (String arg : args) {
if (arg.startsWith("-solver=")) {
solver = Solvers.valueOf(arg.substring(8));
} else if (path == null) {
path = Path.of(arg);
} else {
help();
}
}
if (path == null) {
help();
}
Configuration config = Configuration.defaultConfiguration();
LogManager logger = BasicLogManager.create(config);
ShutdownNotifier notifier = ShutdownNotifier.createDummy();
// we need a solver that supports all theories, at least for parsing.
try (SolverContext context =
SolverContextFactory.createSolverContext(config, logger, notifier, solver)) {
List<BooleanFormula> formulas = new ArrayList<>();
// read all formulas from the file
List<String> definitions = new ArrayList<>();
for (String line : Files.readAllLines(path)) {
// we assume a line-based content
if (Iterables.any(
ImmutableList.of(";", "(push ", "(pop ", "(reset", "(set-logic"), line::startsWith)) {
continue;
} else if (line.startsWith("(assert ")) {
BooleanFormula bf =
context.getFormulaManager().parse(Joiner.on("").join(definitions) + line);
formulas.add(bf);
} else {
// it is a definition
definitions.add(line);
}
}
// classify the formulas
FormulaClassifier fc = new FormulaClassifier(context);
formulas.forEach(fc::visit);
System.out.println(fc + ", checked formulas: " + formulas.size());
} catch (InvalidConfigurationException | UnsatisfiedLinkError e) {
// on some machines we support only some solvers,
// thus we can ignore these errors.
logger.logUserException(Level.INFO, e, "Solver " + solver + " is not available.");
} catch (UnsupportedOperationException e) {
logger.logUserException(Level.INFO, e, e.getMessage());
}
}
private static void help() {
throw new AssertionError("run $> TOOL [-solver=SOLVER] PATH");
}
public FormulaClassifier(SolverContext pContext) {
context = pContext;
mgr = context.getFormulaManager();
}
public void visit(BooleanFormula f) {
// first split formula into atoms to avoid repeated analysis of common subtrees.
AtomCollector atomCollector = new AtomCollector();
mgr.getBooleanFormulaManager().visitRecursively(f, atomCollector);
if (atomCollector.hasQuantifiers) {
v.hasQuantifiers = true;
}
// then analyze each part
for (BooleanFormula part : atomCollector.atoms) {
int levelLA = mgr.visit(part, v);
levelLinearArithmetic = Math.max(levelLA, levelLinearArithmetic);
}
}
@Override
public String toString() {
// build logic string
StringBuilder logic = new StringBuilder();
if (!v.hasQuantifiers) {
logic.append("QF_");
}
if (v.hasArrays) {
logic.append("A");
}
if (v.hasUFs) {
logic.append("UF");
}
if (v.hasBVs) {
logic.append("BV");
}
if (v.nonLinearArithmetic || v.linearArithmetic) {
if (v.hasInts && v.hasReals) {
if (v.nonLinearArithmetic) {
logic.append("N");
} else if (v.linearArithmetic) {
logic.append("L");
}
logic.append("IRA");
} else if (v.hasInts) {
if (v.nonLinearArithmetic) {
logic.append("N");
} else if (v.linearArithmetic) {
logic.append("L");
}
logic.append("IA");
} else if (v.hasReals) {
if (v.nonLinearArithmetic) {
logic.append("N");
} else if (v.linearArithmetic) {
logic.append("L");
}
logic.append("RA");
}
}
if (v.hasFloats) {
// TODO forthcoming, see http://smtlib.cs.uiowa.edu/logics.shtml
logic.append("FP");
}
return logic.toString();
}
private static class AtomCollector extends DefaultBooleanFormulaVisitor<TraversalProcess> {
private final Collection<BooleanFormula> atoms = new LinkedHashSet<>();
boolean hasQuantifiers = false;
@Override
protected TraversalProcess visitDefault() {
return TraversalProcess.CONTINUE;
}
@Override
public TraversalProcess visitAtom(
BooleanFormula atom, FunctionDeclaration<BooleanFormula> funcDecl) {
atoms.add(atom);
return TraversalProcess.CONTINUE;
}
@Override
public TraversalProcess visitQuantifier(
Quantifier quantifier,
BooleanFormula quantifiedAST,
List<Formula> boundVars,
BooleanFormula body) {
hasQuantifiers = true;
return visitDefault();
}
}
private class Classifier implements FormulaVisitor<Integer> {
boolean hasUFs = false;
boolean hasQuantifiers = false;
boolean hasFloats = false;
boolean hasInts = false;
boolean hasReals = false;
boolean hasBVs = false;
boolean hasArrays = false;
boolean linearArithmetic = false;
boolean nonLinearArithmetic = false;
void checkType(Formula f) {
FormulaType<Formula> type = mgr.getFormulaType(f);
if (type.isIntegerType()) {
hasInts = true;
}
if (type.isRationalType()) {
hasReals = true;
}
if (type.isFloatingPointType()) {
hasFloats = true;
}
if (type.isBitvectorType()) {
hasBVs = true;
}
if (type.isArrayType()) {
hasArrays = true;
}
}
@Override
public Integer visitFreeVariable(Formula pF, String pName) {
checkType(pF);
return 1;
}
@Override
public Integer visitBoundVariable(Formula pF, int pDeBruijnIdx) {
checkType(pF);
return 1;
}
@Override
public Integer visitConstant(Formula pF, Object pValue) {
checkType(pF);
return 0;
}
@Override
public Integer visitFunction(
Formula pF, List<Formula> args, FunctionDeclaration<?> pFunctionDeclaration) {
if (pFunctionDeclaration.getKind() == FunctionDeclarationKind.UF) {
hasUFs = true;
}
checkType(pF);
int numNonConstantArgs = 0;
int allArgLevel = 0;
for (Formula arg : args) {
int argLevel = mgr.visit(arg, this);
if (argLevel >= 1) {
numNonConstantArgs++;
}
allArgLevel = Math.max(allArgLevel, argLevel);
}
switch (pFunctionDeclaration.getKind()) {
case MUL:
case BV_MUL:
case DIV:
case BV_UDIV:
case BV_SDIV:
case MODULO:
case BV_UREM:
case BV_SREM:
if (numNonConstantArgs >= 2) {
nonLinearArithmetic = true;
return allArgLevel + 1;
}
// $FALL-THROUGH$
default:
if (pFunctionDeclaration.getType().isBooleanType()) {
if (EnumSet.of(
FunctionDeclarationKind.LT,
FunctionDeclarationKind.LTE,
FunctionDeclarationKind.GT,
FunctionDeclarationKind.GTE)
.contains(pFunctionDeclaration.getKind())) {
for (Formula arg : args) {
FormulaType<Formula> type = mgr.getFormulaType(arg);
if (type.isIntegerType() || type.isRationalType()) {
linearArithmetic = true;
}
}
}
return 0;
} else {
if (pFunctionDeclaration.getKind() != FunctionDeclarationKind.UF) {
linearArithmetic = true;
}
return allArgLevel;
}
}
}
@Override
public Integer visitQuantifier(
BooleanFormula pF,
Quantifier pQuantifier,
List<Formula> pBoundVariables,
BooleanFormula pBody) {
hasQuantifiers = true;
checkType(pF);
return mgr.visit(pBody, this);
}
}
}
| 10,235 | 29.555224 | 98 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/example/HoudiniApp.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: Unlicense OR Apache-2.0 OR MIT
package org.sosy_lab.java_smt.example;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
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.log.BasicLogManager;
import org.sosy_lab.common.log.LogManager;
import org.sosy_lab.java_smt.SolverContextFactory;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.BooleanFormulaManager;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.FormulaManager;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.Model;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.ProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
import org.sosy_lab.java_smt.api.visitors.FormulaTransformationVisitor;
/**
* This application executes the inductive-invariant synthesis algorithm called "Houdini" taken from
* the paper Flanagan and Leino: "Houdini, an Annotation Assistant for ESC/Java".
*
* <p>It considers a program manipulating a set X of variables, defined by an initial condition I(X)
* (given as lemmas) and a transition relation T(X, X'). Both I and T are quantifier-free
* first-order formulas.
*
* <p>A lemma F is called inductive with respect to T if it implies itself over the primed variables
* after the transition: FORALL X, X' . IMPLIES( AND( F(X), T(X, X') ), F(X')) i.e. in other words,
* the formula AND( F(X), T(X, X'), NOT(F(X')) ) is unsatisfiable.
*
* <p>The Houdini algorithm finds and returns a maximal inductive subset L_I of a given set L of
* candidate lemmas. It repeatedly checks the conjunction of L for inductiveness and updates L to
* exclude the lemmas that give rise to counterexamples-to-induction.
*/
public class HoudiniApp {
private final FormulaManager fmgr;
private final BooleanFormulaManager bfmgr;
private final SolverContext context;
public static void main(String... args)
throws InvalidConfigurationException, SolverException, InterruptedException {
Configuration config = Configuration.defaultConfiguration();
LogManager logger = BasicLogManager.create(config);
ShutdownNotifier notifier = ShutdownNotifier.createDummy();
// this example executes the Houdini algorithm for all available solvers
for (Solvers solver : Solvers.values()) {
// create the solver context, which includes all necessary parts for building, manipulating,
// and solving formulas.
try (SolverContext solverContext =
SolverContextFactory.createSolverContext(config, logger, notifier, solver)) {
logger.log(
Level.WARNING, "Using solver " + solver + " in version " + solverContext.getVersion());
// initialize Houdini
HoudiniApp houdini = new HoudiniApp(solverContext);
IntegerFormulaManager ifmgr = solverContext.getFormulaManager().getIntegerFormulaManager();
// create some symbols for the example
IntegerFormula x = ifmgr.makeVariable("X");
IntegerFormula xPrimed = ifmgr.makeVariable("X'");
IntegerFormula one = ifmgr.makeNumber(1);
// create boolean formulas for the example,
// for the transition X'=X+1 the lemma X>1 is valid and X<1 is invalid.
List<BooleanFormula> lemmas =
ImmutableList.of(ifmgr.greaterThan(x, one), ifmgr.lessThan(x, one));
BooleanFormula transition = ifmgr.equal(xPrimed, ifmgr.add(x, one));
// use Houdini and compute the maximal inductive subset
List<BooleanFormula> result = houdini.houdini(lemmas, transition);
logger.log(Level.INFO, "Houdini returned", result);
} catch (InvalidConfigurationException | UnsatisfiedLinkError e) {
// on some machines we support only some solvers,
// thus we can ignore these errors.
logger.logUserException(Level.INFO, e, "Solver " + solver + " is not available.");
} catch (UnsupportedOperationException e) {
logger.logUserException(Level.INFO, e, e.getMessage());
}
}
}
public HoudiniApp(SolverContext solverContext) {
context = solverContext;
fmgr = context.getFormulaManager();
bfmgr = context.getFormulaManager().getBooleanFormulaManager();
}
/** create a temporary symbol using the given index. */
private BooleanFormula getSelectorVar(int idx) {
return bfmgr.makeVariable("SEL_" + idx);
}
/** traverse the formula and replace all symbols in the formula with their primed version. */
private BooleanFormula prime(BooleanFormula input) {
return fmgr.transformRecursively(
input,
new FormulaTransformationVisitor(fmgr) {
@Override
public Formula visitFreeVariable(Formula f, String name) {
return fmgr.makeVariable(fmgr.getFormulaType(f), name + "'");
}
});
}
/**
* execute the Houdini algorithm to get the maximal inductive subset L_I for the given lemmas and
* the transition.
*/
public List<BooleanFormula> houdini(List<BooleanFormula> lemmas, BooleanFormula transition)
throws SolverException, InterruptedException {
List<BooleanFormula> annotated = new ArrayList<>();
List<BooleanFormula> annotatedPrimes = new ArrayList<>();
Map<Integer, BooleanFormula> indexed = new HashMap<>();
for (int i = 0; i < lemmas.size(); i++) {
BooleanFormula lemma = lemmas.get(i);
BooleanFormula primed = prime(lemma);
annotated.add(bfmgr.or(getSelectorVar(i), lemma));
annotatedPrimes.add(bfmgr.or(getSelectorVar(i), primed));
indexed.put(i, lemma);
}
// create a prover environment for solving the formulas and receiving a model
try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) {
prover.addConstraint(transition);
prover.addConstraint(bfmgr.and(annotated));
prover.addConstraint(bfmgr.not(bfmgr.and(annotatedPrimes)));
while (!prover.isUnsat()) {
try (Model m = prover.getModel()) {
for (int i = 0; i < annotatedPrimes.size(); i++) {
BooleanFormula annotatedPrime = annotatedPrimes.get(i);
if (!m.evaluate(annotatedPrime)) {
prover.addConstraint(getSelectorVar(i));
indexed.remove(i);
}
}
}
}
}
return new ArrayList<>(indexed.values());
}
}
| 7,072 | 40.122093 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/example/Interpolation.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: Unlicense OR Apache-2.0 OR MIT
package org.sosy_lab.java_smt.example;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
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.log.BasicLogManager;
import org.sosy_lab.common.log.LogManager;
import org.sosy_lab.java_smt.SolverContextFactory;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverException;
/** Examples for Craig/sequential/tree interpolation. */
public class Interpolation {
private Interpolation() {
// never called
}
public static void main(String... args)
throws InvalidConfigurationException, SolverException, InterruptedException {
// set up a basic environment
Configuration config = Configuration.defaultConfiguration();
LogManager logger = BasicLogManager.create(config);
ShutdownNotifier notifier = ShutdownNotifier.createDummy();
// choose solver
Solvers solver = Solvers.SMTINTERPOL; // works for all interpolation strategies
// setup context
try (SolverContext context =
SolverContextFactory.createSolverContext(config, logger, notifier, solver);
InterpolatingProverEnvironment<?> prover =
context.newProverEnvironmentWithInterpolation()) {
logger.log(Level.WARNING, "Using solver " + solver + " in version " + context.getVersion());
IntegerFormulaManager imgr = context.getFormulaManager().getIntegerFormulaManager();
// example
prover.push();
interpolateExample(prover, imgr, logger);
prover.pop();
// and another example
prover.push();
interpolateProgramTrace(prover, imgr, logger);
prover.pop();
} catch (InvalidConfigurationException | UnsatisfiedLinkError e) {
// on some machines we support only some solvers,
// thus we can ignore these errors.
logger.logUserException(Level.INFO, e, "Solver " + solver + " is not available.");
} catch (UnsupportedOperationException e) {
logger.logUserException(Level.INFO, e, e.getMessage());
}
}
/**
* Example taken from SMTInterpol, <a
* href="http://ultimate.informatik.uni-freiburg.de/smtinterpol/interpolation.smt2">example as
* SMT-LIB</a>:
*
* <pre>
* (set-option :print-success false)
* (set-option :produce-proofs true)
* (set-logic QF_LIA)
* (declare-fun x () Int)
* (declare-fun y () Int)
* (assert (! (> x y) :named IP_0))
* (assert (! (= x 0) :named IP_1))
* (assert (! (> y 0) :named IP_2))
* (check-sat)
* (get-interpolants IP_0 IP_1 IP_2) // example 1 (1a and 1b)
* (get-interpolants IP_1 (and IP_0 IP_2)) // example 2 (2a and 2b)
* (exit)
* </pre>
*/
private static <T> void interpolateExample(
InterpolatingProverEnvironment<T> prover, IntegerFormulaManager imgr, LogManager logger)
throws InterruptedException, SolverException {
// create some variables.
IntegerFormula x = imgr.makeVariable("x");
IntegerFormula y = imgr.makeVariable("y");
IntegerFormula zero = imgr.makeNumber(0);
// create and assert some formulas.
// instead of 'named' formulas, we return a 'handle' (of generic type T)
T ip0 = prover.addConstraint(imgr.greaterThan(x, y));
T ip1 = prover.addConstraint(imgr.equal(x, zero));
T ip2 = prover.addConstraint(imgr.greaterThan(y, zero));
// check for satisfiability
boolean unsat = prover.isUnsat();
Preconditions.checkState(unsat, "the example for interpolation should be UNSAT");
List<BooleanFormula> itps;
{
// example 1a :
// get a sequence of interpolants for three formulas: (get-interpolants IP_0 IP_1 IP_2).
itps = prover.getSeqInterpolants0(ImmutableList.of(ip0, ip1, ip2));
logger.log(Level.INFO, "1a :: Interpolants for [{ip0},{ip1},{ip2}] are:", itps);
}
{
// example 1b :
// alternative solution ... with more code and partitioned formulas.
Set<T> partition0 = ImmutableSet.of(ip0);
Set<T> partition1 = ImmutableSet.of(ip1);
Set<T> partition2 = ImmutableSet.of(ip2);
itps = prover.getSeqInterpolants(ImmutableList.of(partition0, partition1, partition2));
logger.log(Level.INFO, "1b :: Interpolants for [{ip0},{ip1},{ip2}] are:", itps);
}
{
// example 2a :
// get a sequence of interpolants for two formulas: (get-interpolants IP_1 (and IP_0 IP_2)).
Set<T> partition3 = ImmutableSet.of(ip0);
Set<T> partition4 = ImmutableSet.of(ip1, ip2);
itps = prover.getSeqInterpolants(ImmutableList.of(partition3, partition4));
logger.log(Level.INFO, "2a :: Interpolants for [{ip0},{ip1,ip2}] are:", itps);
}
{
// example 2b :
// alternative solution, works when there are exactly two (!) groups of formulas.
// only one part is given as parameter, the rest is taken from the already asserted formulas.
BooleanFormula itp = prover.getInterpolant(ImmutableList.of(ip0));
logger.log(Level.INFO, "2b :: Interpolants for [{ip0},{ip1,ip2}] are:", itp);
}
}
/**
* Example for encoding a program path and computing interpolants along the path. Taken from <a
* href="http://satsmt2014.forsyte.at/files/2014/01/interpolation_philipp.pdf">slides</a> from
* Philipp Rümmer.
*
* <p>Example trace of a program:
*
* <pre>
* i=0
* k=j
* assume (i<50)
* i++
* k++
* assume (i>=50)
* assume (j==0)
* assume (k<50)
* </pre>
*/
private static <T> void interpolateProgramTrace(
InterpolatingProverEnvironment<T> prover, IntegerFormulaManager imgr, LogManager logger)
throws InterruptedException, SolverException {
// create some variables.
// primed variable needed for 'self-assignments', alternatively use SSA-indices.
IntegerFormula i = imgr.makeVariable("i");
IntegerFormula i1 = imgr.makeVariable("i'");
IntegerFormula j = imgr.makeVariable("j");
IntegerFormula k = imgr.makeVariable("k");
IntegerFormula k1 = imgr.makeVariable("k'");
IntegerFormula zero = imgr.makeNumber(0);
IntegerFormula one = imgr.makeNumber(1);
IntegerFormula fifty = imgr.makeNumber(50);
// create and assert some formulas.
List<BooleanFormula> programTrace =
ImmutableList.of(
imgr.equal(i, zero),
imgr.equal(k, j),
imgr.lessThan(i, fifty),
imgr.equal(i1, imgr.add(i, one)),
imgr.equal(k1, imgr.add(k, one)),
imgr.greaterOrEquals(i1, fifty),
imgr.equal(j, zero),
imgr.lessThan(k1, fifty));
// assert all formulas in the prover
List<T> handles = new ArrayList<>();
for (BooleanFormula step : programTrace) {
handles.add(prover.addConstraint(step));
}
// check for satisfiability
boolean unsat = prover.isUnsat();
Preconditions.checkState(unsat, "the example for interpolation should be UNSAT");
// get a sequence of interpolants for the program trace.
List<BooleanFormula> itps = prover.getSeqInterpolants0(handles);
logger.log(Level.INFO, "Interpolants for the program trace are:", itps);
}
}
| 7,973 | 35.916667 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/example/NQueens.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: Unlicense OR Apache-2.0 OR MIT
package org.sosy_lab.java_smt.example;
import com.google.common.collect.ImmutableList;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.Scanner;
import java.util.logging.Level;
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.log.BasicLogManager;
import org.sosy_lab.common.log.LogManager;
import org.sosy_lab.java_smt.SolverContextFactory;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
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;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
/**
* This example program solves a NQueens problem of given size and prints a possible solution.
*
* <p>For example, the Queen can be placed in these ways for a field size of 4:
*
* <pre>
* .Q..
* ...Q
* Q...
* ..Q.
* </pre>
*/
public class NQueens {
private final SolverContext context;
private final BooleanFormulaManager bmgr;
private final int n;
private NQueens(SolverContext pContext, int n) {
context = pContext;
bmgr = context.getFormulaManager().getBooleanFormulaManager();
this.n = n;
}
public static void main(String... args)
throws InvalidConfigurationException, SolverException, InterruptedException {
Configuration config = Configuration.defaultConfiguration();
LogManager logger = BasicLogManager.create(config);
ShutdownNotifier notifier = ShutdownNotifier.createDummy();
Solvers solver = Solvers.SMTINTERPOL;
try (SolverContext context =
SolverContextFactory.createSolverContext(config, logger, notifier, solver)) {
try (Scanner sc = new Scanner(System.in, Charset.defaultCharset().name())) {
// Takes input from the user for number of queens to be placed
System.out.println("Enter the number of Queens to be " + "placed on the board:");
int n = sc.nextInt();
NQueens myQueen = new NQueens(context, n);
Optional<boolean[][]> solutions = myQueen.solve();
if (solutions.isEmpty()) {
System.out.println("No solutions found.");
} else {
System.out.println("Solution:");
for (boolean[] row : solutions.orElseThrow()) {
for (boolean col : row) {
System.out.print(col ? "Q " : "_ ");
}
System.out.println();
}
System.out.println();
}
}
} catch (InvalidConfigurationException | UnsatisfiedLinkError e) {
logger.logUserException(Level.INFO, e, "Solver " + solver + " is not available.");
} catch (UnsupportedOperationException e) {
logger.logUserException(Level.INFO, e, e.getMessage());
}
}
/**
* Creates a 2D array of BooleanFormula objects to represent the variables for each cell in a grid
* of size N x N.
*
* @return a 2D array of BooleanFormula objects, where each BooleanFormula object represents a
* variable for a cell in the grid.
*/
private BooleanFormula[][] getSymbols() {
final BooleanFormula[][] symbols = new BooleanFormula[n][n];
for (int row = 0; row < n; row++) {
for (int col = 0; col < n; col++) {
symbols[row][col] = bmgr.makeVariable("q_" + row + "_" + col);
}
}
return symbols;
}
/**
* Rule 1: At least one queen per row, or we can say make sure that there are N Queens on the
* board.
*
* @param symbols a 2D Boolean array representing the board. Each element is true if there is a
* queen in that cell, false otherwise.
* @return a List of BooleanFormulas representing the rules for this constraint.
*/
private List<BooleanFormula> rowRule1(BooleanFormula[][] symbols) {
final List<BooleanFormula> rules = new ArrayList<>();
for (BooleanFormula[] rowSymbols : symbols) {
List<BooleanFormula> clause = new ArrayList<>();
for (int i = 0; i < n; i++) {
clause.add(rowSymbols[i]);
}
rules.add(bmgr.or(clause));
}
return rules;
}
/**
* Rule 2: Add constraints to ensure that at most one queen is placed in each row. For n=4:
*
* <pre>
* 0123
* 0 ----
* 1 ----
* 2 ----
* 3 ----
* </pre>
*
* <p>We add a negation of the conjunction of all possible pairs of variables in each row.
*
* @param symbols a 2D array of BooleanFormula objects representing the variables for each cell on
* the board.
* @return a list of BooleanFormula objects representing the constraints added by this rule.
*/
private List<BooleanFormula> rowRule2(BooleanFormula[][] symbols) {
final List<BooleanFormula> rules = new ArrayList<>();
for (BooleanFormula[] rowSymbol : symbols) {
for (int j1 = 0; j1 < n; j1++) {
for (int j2 = j1 + 1; j2 < n; j2++) {
rules.add(bmgr.not(bmgr.and(rowSymbol[j1], rowSymbol[j2])));
}
}
}
return rules;
}
/**
* Rule 3: Add constraints to ensure that at most one queen is placed in each column. For n=4:
*
* <pre>
* 0123
* 0 ||||
* 1 ||||
* 2 ||||
* 3 ||||
* </pre>
*
* <p>We add a negation of the conjunction of all possible pairs of variables in each column.
*
* @param symbols a 2D array of BooleanFormula representing the placement of queens on the
* chessboard
* @return a list of BooleanFormula objects representing the constraints added by this rule.
*/
private List<BooleanFormula> columnRule(BooleanFormula[][] symbols) {
final List<BooleanFormula> rules = new ArrayList<>();
for (int j = 0; j < n; j++) {
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = i1 + 1; i2 < n; i2++) {
rules.add(bmgr.not(bmgr.and(symbols[i1][j], symbols[i2][j])));
}
}
}
return rules;
}
/**
* Rule 4: At most one queen per diagonal transform the field (=symbols) from square shape into a
* (downwards/upwards directed) rhombus that is embedded in a rectangle
* (=downwardDiagonal/upwardDiagonal). For example for N=4 from this square:
*
* <pre>
* 0123
* 0 xxxx
* 1 xxxx
* 2 xxxx
* 3 xxxx
* </pre>
*
* <p>to this rhombus/rectangle:
*
* <pre>
* 0123
* 0 x---
* 1 xx--
* 2 xxx-
* 3 xxxx
* 4 -xxx
* 5 --xx
* 6 ---x
* </pre>
*
* @param symbols a two-dimensional array of Boolean formulas representing the chessboard
* configuration
* @return a list of BooleanFormula objects representing the constraints added by this rule.
*/
private List<BooleanFormula> diagonalRule(BooleanFormula[][] symbols) {
final List<BooleanFormula> rules = new ArrayList<>();
int numDiagonals = 2 * n - 1;
BooleanFormula[][] downwardDiagonal = new BooleanFormula[numDiagonals][n];
BooleanFormula[][] upwardDiagonal = new BooleanFormula[numDiagonals][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
downwardDiagonal[i + j][i] = symbols[i][j];
upwardDiagonal[i - j + n - 1][i] = symbols[i][j];
}
}
for (int d = 0; d < numDiagonals; d++) {
BooleanFormula[] diagonal1 = downwardDiagonal[d];
BooleanFormula[] diagonal2 = upwardDiagonal[d];
List<BooleanFormula> downwardDiagonalQueen = new ArrayList<>();
List<BooleanFormula> upwardDiagonalQueen = new ArrayList<>();
for (int i = 0; i < n; i++) {
if (diagonal1[i] != null) {
downwardDiagonalQueen.add(diagonal1[i]);
}
if (diagonal2[i] != null) {
upwardDiagonalQueen.add(diagonal2[i]);
}
}
for (int i = 0; i < downwardDiagonalQueen.size(); i++) {
for (int j = i + 1; j < downwardDiagonalQueen.size(); j++) {
rules.add(bmgr.not(bmgr.and(downwardDiagonalQueen.get(i), downwardDiagonalQueen.get(j))));
}
}
for (int i = 0; i < upwardDiagonalQueen.size(); i++) {
for (int j = i + 1; j < upwardDiagonalQueen.size(); j++) {
rules.add(bmgr.not(bmgr.and(upwardDiagonalQueen.get(i), upwardDiagonalQueen.get(j))));
}
}
}
return rules;
}
/**
* Returns a boolean value indicating whether a queen is placed on the cell corresponding to the
* given row and column.
*
* @param symbols a 2D BooleanFormula array representing the cells of the chess board.
* @param model the Model object representing the current state of the board.
* @param row the row index of the cell to check.
* @param col the column index of the cell to check.
* @return true if a queen is placed on the cell, false otherwise.
*/
private boolean getValue(BooleanFormula[][] symbols, Model model, int row, int col) {
return Boolean.TRUE.equals(model.evaluate(symbols[row][col]));
}
/**
* Solves the N-Queens problem for the given board size and returns a possible solution.
*
* @return A two-dimensional array of booleans representing the solution. Returns {@code empty
* object } if no solution exists.
* @throws InterruptedException if the solving process is interrupted
* @throws SolverException if an error occurs during the solving process
*/
private Optional<boolean[][]> solve() throws InterruptedException, SolverException {
BooleanFormula[][] symbols = getSymbols();
List<BooleanFormula> rules =
ImmutableList.<BooleanFormula>builder()
.addAll(rowRule1(symbols))
.addAll(rowRule2(symbols))
.addAll(columnRule(symbols))
.addAll(diagonalRule(symbols))
.build();
// solve N-Queens
try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) {
prover.push(bmgr.and(rules));
boolean isUnsolvable = prover.isUnsat();
if (isUnsolvable) {
return Optional.empty();
}
// get model and convert it
boolean[][] solution = new boolean[n][n];
try (Model model = prover.getModel()) {
for (int row = 0; row < n; row++) {
for (int col = 0; col < n; col++) {
solution[row][col] = getValue(symbols, model, row, col);
}
}
return Optional.of(solution);
}
}
}
}
| 10,788 | 34.490132 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/example/OptimizationFormulaWeights.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: Unlicense OR Apache-2.0 OR MIT
package org.sosy_lab.java_smt.example;
import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.logging.Level;
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.log.BasicLogManager;
import org.sosy_lab.common.log.LogManager;
import org.sosy_lab.common.rationals.Rational;
import org.sosy_lab.java_smt.SolverContextFactory;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
import org.sosy_lab.java_smt.api.BooleanFormulaManager;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.Model;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.OptimizationProverEnvironment;
import org.sosy_lab.java_smt.api.OptimizationProverEnvironment.OptStatus;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
/**
* Example for optimizing the weight of some constraints. For a given set of formulas, the weight of
* the satisfied formulas should be maximal and the weight of unsatisfied formulas should be
* minimal.
*/
public class OptimizationFormulaWeights {
private OptimizationFormulaWeights() {
// never called
}
public static void main(String... args)
throws InvalidConfigurationException, SolverException, InterruptedException {
Configuration config = Configuration.defaultConfiguration();
LogManager logger = BasicLogManager.create(config);
ShutdownNotifier notifier = ShutdownNotifier.createDummy();
Solvers solver = Solvers.Z3; // Z3 works for optimization
try (SolverContext context =
SolverContextFactory.createSolverContext(config, logger, notifier, solver);
OptimizationProverEnvironment prover =
context.newOptimizationProverEnvironment(ProverOptions.GENERATE_MODELS)) {
logger.log(Level.WARNING, "Using solver " + solver + " in version " + context.getVersion());
BooleanFormulaManager bmgr = context.getFormulaManager().getBooleanFormulaManager();
IntegerFormulaManager imgr = context.getFormulaManager().getIntegerFormulaManager();
optimizeWithWeights(prover, bmgr, imgr, logger);
} catch (InvalidConfigurationException | UnsatisfiedLinkError e) {
// on some machines we support only some solvers,
// thus we can ignore these errors.
logger.logUserException(Level.INFO, e, "Solver " + solver + " is not available.");
} catch (UnsupportedOperationException e) {
logger.logUserException(Level.INFO, e, e.getMessage());
}
}
/** add some constraints and then solve them with optimization according to weights. */
private static void optimizeWithWeights(
OptimizationProverEnvironment prover,
BooleanFormulaManager bmgr,
IntegerFormulaManager imgr,
LogManager logger)
throws InterruptedException, SolverException {
// create some symbols and formulas
IntegerFormula x = imgr.makeVariable("x");
IntegerFormula y = imgr.makeVariable("y");
IntegerFormula z = imgr.makeVariable("z");
IntegerFormula zero = imgr.makeNumber(0);
IntegerFormula four = imgr.makeNumber(4);
IntegerFormula ten = imgr.makeNumber(10);
IntegerFormula scoreBasic = imgr.makeNumber(0);
IntegerFormula scoreLow = imgr.makeNumber(2);
IntegerFormula scoreMedium = imgr.makeNumber(4);
IntegerFormula scoreHigh = imgr.makeNumber(10);
// add some very important constraints: x<10, y<10, z<10, 10=x+y+z
prover.addConstraint(
bmgr.and(
imgr.lessOrEquals(x, ten), // very important -> direct constraint
imgr.lessOrEquals(y, ten), // very important -> direct constraint
imgr.lessOrEquals(z, ten), // very important -> direct constraint
imgr.equal(ten, imgr.add(x, imgr.add(y, z)))));
// generate weighted formulas: if a formula should be satisfied,
// use higher weight for the positive instance than for its negated instance.
List<IntegerFormula> weights =
ImmutableList.of(
bmgr.ifThenElse(imgr.lessOrEquals(x, zero), scoreHigh, scoreBasic), // important
bmgr.ifThenElse(imgr.lessOrEquals(x, four), scoreHigh, scoreBasic), // important
bmgr.ifThenElse(imgr.lessOrEquals(y, zero), scoreMedium, scoreBasic), // less important
bmgr.ifThenElse(imgr.lessOrEquals(y, four), scoreMedium, scoreBasic), // less important
bmgr.ifThenElse(imgr.lessOrEquals(z, zero), scoreLow, scoreBasic), // not important
bmgr.ifThenElse(imgr.lessOrEquals(z, four), scoreHigh, scoreBasic) // important
);
// Maximize sum of weights
int handle = prover.maximize(imgr.sum(weights));
OptStatus response = prover.check();
assert response == OptStatus.OPT;
// for integer theory we get the optimal solution directly as model.
// ideal solution: sum=32 with e.g. x=0,y=6,z=4 or x=0,y=7,z=3 or x=0,y=8,z=2 ...
try (Model model = prover.getModel()) {
logger.log(
Level.INFO,
"maximal sum ",
prover.upper(handle, Rational.ZERO).orElseThrow(),
"with model",
model.asList());
}
}
}
| 5,638 | 41.719697 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/example/OptimizationIntReal.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: Unlicense OR Apache-2.0 OR MIT
package org.sosy_lab.java_smt.example;
import java.util.Optional;
import java.util.logging.Level;
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.log.BasicLogManager;
import org.sosy_lab.common.log.LogManager;
import org.sosy_lab.common.rationals.Rational;
import org.sosy_lab.java_smt.SolverContextFactory;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
import org.sosy_lab.java_smt.api.BooleanFormulaManager;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.Model;
import org.sosy_lab.java_smt.api.NumeralFormula;
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.OptimizationProverEnvironment;
import org.sosy_lab.java_smt.api.OptimizationProverEnvironment.OptStatus;
import org.sosy_lab.java_smt.api.RationalFormulaManager;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
/**
* Example for optimizing 'x' with the constraint '0 <= x < 10'. We show the difference
* between optimizing in integer and rational logic.
*/
public class OptimizationIntReal {
/** A correct value is determined in a region of size EPSILON around the real bound. */
private static final Rational EPSILON = Rational.ofString("1/1000");
private OptimizationIntReal() {
// never called
}
public static void main(String... args)
throws InvalidConfigurationException, SolverException, InterruptedException {
Configuration config = Configuration.defaultConfiguration();
LogManager logger = BasicLogManager.create(config);
ShutdownNotifier notifier = ShutdownNotifier.createDummy();
Solvers solver = Solvers.Z3; // Z3 works for optimization
optimizeWithIntegers(config, logger, notifier, solver);
optimizeWithRationals(config, logger, notifier, solver);
}
/** Solve the problem with integer logic. */
private static void optimizeWithIntegers(
Configuration config, LogManager logger, ShutdownNotifier notifier, Solvers solver)
throws InterruptedException, SolverException {
// create solver context
try (SolverContext context =
SolverContextFactory.createSolverContext(config, logger, notifier, solver);
OptimizationProverEnvironment prover =
context.newOptimizationProverEnvironment(ProverOptions.GENERATE_MODELS)) {
logger.log(Level.WARNING, "Using solver " + solver + " in version " + context.getVersion());
BooleanFormulaManager bmgr = context.getFormulaManager().getBooleanFormulaManager();
IntegerFormulaManager nmgr = context.getFormulaManager().getIntegerFormulaManager();
IntegerFormula x = nmgr.makeVariable("x");
// assert 0 <= x < 10
prover.addConstraint(
bmgr.and(
nmgr.greaterOrEquals(x, nmgr.makeNumber(0)), nmgr.lessThan(x, nmgr.makeNumber(10))));
logger.log(Level.INFO, "optimizing with integer logic");
printUpperAndLowerBound(prover, x, logger);
} catch (InvalidConfigurationException | UnsatisfiedLinkError e) {
// on some machines we support only some solvers,
// thus we can ignore these errors.
logger.logUserException(Level.INFO, e, "Solver " + solver + " is not available.");
} catch (UnsupportedOperationException e) {
logger.logUserException(Level.INFO, e, e.getMessage());
}
}
/** Solve the problem with rational logic. */
private static void optimizeWithRationals(
Configuration config, LogManager logger, ShutdownNotifier notifier, Solvers solver)
throws InterruptedException, SolverException {
// create solver context
try (SolverContext context =
SolverContextFactory.createSolverContext(config, logger, notifier, solver);
OptimizationProverEnvironment prover =
context.newOptimizationProverEnvironment(ProverOptions.GENERATE_MODELS)) {
BooleanFormulaManager bmgr = context.getFormulaManager().getBooleanFormulaManager();
RationalFormulaManager nmgr = context.getFormulaManager().getRationalFormulaManager();
RationalFormula x = nmgr.makeVariable("x");
prover.addConstraint(
bmgr.and(
nmgr.greaterOrEquals(x, nmgr.makeNumber(0)), nmgr.lessThan(x, nmgr.makeNumber(10))));
logger.log(Level.INFO, "optimizing with rational logic");
printUpperAndLowerBound(prover, x, logger);
} catch (InvalidConfigurationException | UnsatisfiedLinkError e) {
// on some machines we support only some solvers,
// thus we can ignore these errors.
logger.logUserException(Level.INFO, e, "Solver " + solver + " is not available.");
} catch (UnsupportedOperationException e) {
logger.logUserException(Level.INFO, e, e.getMessage());
}
}
/** computes the lower and upper bound for the symbol 'x' and prints possible models. */
private static void printUpperAndLowerBound(
OptimizationProverEnvironment prover, NumeralFormula x, LogManager logger)
throws InterruptedException, SolverException {
prover.push();
{ // minimize x and get a lower bound of x: x >= 0
// --> bound is 0
int handleX = prover.minimize(x);
OptStatus status = prover.check();
assert status == OptStatus.OPT;
Optional<Rational> lower = prover.lower(handleX, EPSILON);
try (Model model = prover.getModel()) {
logger.log(Level.INFO, "lower bound:", lower.orElseThrow(), "with model:", model.asList());
}
}
prover.pop();
prover.push();
{ // maximize x and get an upper bound of x: x < 10
// --> bound is (10 - EPSILON) for rational symbols and 9 for integer symbols.
int handleX = prover.maximize(x);
OptStatus status = prover.check();
assert status == OptStatus.OPT;
Optional<Rational> upper = prover.upper(handleX, EPSILON);
try (Model model = prover.getModel()) {
logger.log(Level.INFO, "upper bound:", upper.orElseThrow(), "with model:", model.asList());
}
}
prover.pop();
}
}
| 6,565 | 40.821656 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/example/PrettyPrinter.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: Unlicense OR Apache-2.0 OR MIT
package org.sosy_lab.java_smt.example;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.logging.Level;
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.log.BasicLogManager;
import org.sosy_lab.common.log.LogManager;
import org.sosy_lab.java_smt.SolverContextFactory;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverException;
import org.sosy_lab.java_smt.utils.PrettyPrinter.PrinterOption;
import org.sosy_lab.java_smt.utils.SolverUtils;
/** This program parses user-given formulas and prints them in a pretty format. */
@SuppressWarnings("unused")
public class PrettyPrinter {
/** Utility class without a public constructor. */
private PrettyPrinter() {}
/** We provide different types of output for the user. */
private enum Type {
/** dot-output with only boolean nodes. */
DOT,
/** dot-output with all operations/functions split into separate nodes. */
DETAILED_DOT,
/** text-output with only boolean formulas on separate lines. */
TEXT,
/** text-output with all operations/functions split to single lines. */
DETAILED_TEXT
}
public static void main(String... args)
throws InvalidConfigurationException, SolverException, InterruptedException, IOException {
if (args.length == 0) {
help();
}
Solvers solver = Solvers.MATHSAT5;
Type type = Type.TEXT;
Path path = null;
for (String arg : args) {
if (arg.startsWith("-solver=")) {
solver = Solvers.valueOf(arg.substring(8));
} else if (arg.startsWith("-type=")) {
type = Type.valueOf(arg.substring(6).toUpperCase(Locale.getDefault()));
} else if (path == null) {
path = Path.of(arg);
} else {
help();
}
}
if (path == null) {
help();
}
Configuration config = Configuration.defaultConfiguration();
LogManager logger = BasicLogManager.create(config);
ShutdownNotifier notifier = ShutdownNotifier.createDummy();
// we need a solver that supports all theories, at least for parsing.
try (SolverContext context =
SolverContextFactory.createSolverContext(config, logger, notifier, solver)) {
List<BooleanFormula> formulas = new ArrayList<>();
// read all formulas from the file
List<String> definitions = new ArrayList<>();
for (String line : Files.readAllLines(path)) {
// we assume a line-based content
if (Iterables.any(
ImmutableList.of(";", "(push ", "(pop ", "(reset", "(set-logic"), line::startsWith)) {
continue;
} else if (line.startsWith("(assert ")) {
BooleanFormula bf =
context.getFormulaManager().parse(Joiner.on("").join(definitions) + line);
formulas.add(bf);
} else {
// it is a definition
definitions.add(line);
}
}
// classify the formulas
org.sosy_lab.java_smt.utils.PrettyPrinter pp =
SolverUtils.prettyPrinter(context.getFormulaManager());
for (BooleanFormula formula : formulas) {
System.out.println(formulaToString(formula, pp, type));
}
} catch (InvalidConfigurationException | UnsatisfiedLinkError e) {
// on some machines we support only some solvers,
// thus we can ignore these errors.
logger.logUserException(Level.INFO, e, "Solver " + solver + " is not available.");
} catch (UnsupportedOperationException e) {
logger.logUserException(Level.INFO, e, e.getMessage());
}
}
private static String formulaToString(
BooleanFormula formula, org.sosy_lab.java_smt.utils.PrettyPrinter pp, Type type) {
switch (type) {
case DETAILED_TEXT:
return pp.formulaToString(formula);
case DOT:
return pp.formulaToDot(formula, PrinterOption.SPLIT_ONLY_BOOLEAN_OPERATIONS);
case DETAILED_DOT:
return pp.formulaToDot(formula);
case TEXT:
default:
return pp.formulaToString(formula, PrinterOption.SPLIT_ONLY_BOOLEAN_OPERATIONS);
}
}
private static void help() {
throw new AssertionError("run $> TOOL [-solver=SOLVER] [-type=TYPE] PATH");
}
}
| 4,926 | 33.943262 | 98 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/example/SolverOverviewTable.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: Unlicense OR Apache-2.0 OR MIT
package org.sosy_lab.java_smt.example;
import static org.sosy_lab.java_smt.api.SolverContext.ProverOptions.GENERATE_UNSAT_CORE_OVER_ASSUMPTIONS;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.function.Supplier;
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.log.LogManager;
import org.sosy_lab.java_smt.SolverContextFactory;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
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.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
/**
* This program takes all installed solvers and checks them for version, theories and features and
* prints them to StdOut in a nice table.
*/
public class SolverOverviewTable {
public static void main(String[] args) throws SolverException, InterruptedException {
final List<SolverInfo> infos = new ArrayList<>();
for (Solvers s : Solvers.values()) {
infos.add(new SolverOverviewTable().getSolverInformation(s));
}
infos.sort(Comparator.comparing(SolverInfo::getName)); // alphabetical ordering
RowBuilder rowBuilder = new RowBuilder();
for (SolverInfo info : infos) {
rowBuilder.addSolver(info);
}
System.out.println(rowBuilder);
}
/**
* Checks for solver-name, version, theories and features.
*
* @param solver to check for information. Taken from Solvers enum only.
* @return Information about the solver you entered or NULL if the solver is not available.
*/
public @Nullable SolverInfo getSolverInformation(Solvers solver)
throws SolverException, InterruptedException {
Configuration config = Configuration.defaultConfiguration();
LogManager logger = LogManager.createNullLogManager();
ShutdownNotifier notifier = ShutdownNotifier.createDummy();
try (SolverContext context =
SolverContextFactory.createSolverContext(config, logger, notifier, solver)) {
String version = context.getVersion();
String theories = String.join(", ", getTheories(context));
String features = String.join(", ", getFeatures(context));
return new SolverInfo(solver, version, theories, features);
} catch (InvalidConfigurationException e) {
// Catches missing solvers
return new SolverInfo(solver, "NOT AVAILABLE", "", "");
}
}
/**
* Checks the solver entered for features. Features checked: Optimization, UnsatCore,
* UnsatCoreWithAssumptions, Assumptions, AllSat, Interpolation
*
* @param context SolverContext you want to check for features.
* @return String with the features of the entered solver separated by a comma. Empty if none
* available.
*/
@SuppressWarnings({"CheckReturnValue", "resource"})
private List<String> getFeatures(SolverContext context)
throws SolverException, InterruptedException {
List<String> features = new ArrayList<>();
// Optimization: Will throw UnsupportedOperationException in creation of prover if not
// available.
try (OptimizationProverEnvironment prover =
context.newOptimizationProverEnvironment(ProverOptions.GENERATE_MODELS)) {
Preconditions.checkNotNull(prover);
features.add("Optimization");
} catch (UnsupportedOperationException e) {
// ignore, feature is not supported.
}
// Interpolation: Will throw UnsupportedOperationException in creation of prover if not
// available.
try (InterpolatingProverEnvironment<?> prover =
context.newProverEnvironmentWithInterpolation(ProverOptions.GENERATE_MODELS)) {
Preconditions.checkNotNull(prover);
features.add("Interpolation");
} catch (UnsupportedOperationException e) {
// ignore, feature is not supported.
}
// We don't care about the return value, just that it doesn't throw an
// UnsupportedOperationException.
try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) {
try {
prover.isUnsatWithAssumptions(ImmutableList.of());
features.add("Assumptions");
} catch (UnsupportedOperationException e) {
// ignore, feature is not supported.
}
}
// UnsatCoreOverAssumptions: throws NullPointerException if available.
try (ProverEnvironment prover =
context.newProverEnvironment(GENERATE_UNSAT_CORE_OVER_ASSUMPTIONS)) {
prover.unsatCoreOverAssumptions(ImmutableList.of());
features.add("UnsatCore /w Assumption");
} catch (UnsupportedOperationException e) {
// ignore, feature is not supported.
}
// UnsatCore: throws UnsupportedOperationException if not available.
try (ProverEnvironment prover =
context.newProverEnvironment(ProverOptions.GENERATE_UNSAT_CORE)) {
prover.push(context.getFormulaManager().getBooleanFormulaManager().makeFalse());
Preconditions.checkState(prover.isUnsat());
Preconditions.checkNotNull(prover.getUnsatCore());
features.add("UnsatCore");
} catch (UnsupportedOperationException e) {
// ignore, feature is not supported.
}
// There is currently no good way of checking if a solver implements AllSat over our
// implementation
return features;
}
/**
* This method checks the SolverContext entered for all its available theories and gives them back
* as String with each theory separated by a comma.
*
* @param context JavaSMT SolverContext of the Solver you want to check for theories.
* @return String of all supported theories except Booleans, separated by a comma. Empty if none
* available.
*/
private List<String> getTheories(SolverContext context) {
List<String> theories = new ArrayList<>();
FormulaManager mgr = context.getFormulaManager();
// Every solver has to have Bool-Theory, should we add it?
addIfAvailable(theories, mgr::getIntegerFormulaManager, "Integer");
addIfAvailable(theories, mgr::getBitvectorFormulaManager, "Bitvector");
addIfAvailable(theories, mgr::getRationalFormulaManager, "Rational");
addIfAvailable(theories, mgr::getFloatingPointFormulaManager, "Float");
addIfAvailable(theories, mgr::getArrayFormulaManager, "Array");
addIfAvailable(theories, mgr::getQuantifiedFormulaManager, "Quantifier");
addIfAvailable(theories, mgr::getUFManager, "UF");
addIfAvailable(theories, mgr::getSLFormulaManager, "Seperation-Logic");
addIfAvailable(theories, mgr::getStringFormulaManager, "String");
return theories;
}
/**
* Try to construct an object and add its name to the list of theories. If an object cannot be
* constructed, we ignore it.
*
* @param names where to add the new name if available.
* @param creator creates the object, allowed to fail with {@link UnsupportedOperationException}.
* @param name the name to be added.
*/
private void addIfAvailable(List<String> names, Supplier<Object> creator, String name) {
try {
if (creator.get() != null) {
names.add(name);
}
} catch (UnsupportedOperationException e) {
// ignore, theory is not supported.
}
}
/** just a wrapper for some data. */
public static class SolverInfo {
private final Solvers solver;
private final String solverVersion;
private final String solverTheories;
private final String solverFeatures;
/**
* Saves the information of a solver.
*
* @param solver Solvers enum object for a solver.
* @param solverVersion Solver version String.
* @param solverTheories Solver theories String.
* @param solverFeatures Solver features String.
*/
SolverInfo(Solvers solver, String solverVersion, String solverTheories, String solverFeatures) {
this.solver = solver;
this.solverVersion = solverVersion;
this.solverTheories = solverTheories;
this.solverFeatures = solverFeatures;
}
public String getName() {
return solver.name();
}
public String getVersion() {
return solverVersion;
}
public String getTheories() {
return solverTheories;
}
public String getFeatures() {
return solverFeatures;
}
}
/** This class builds the table row-by-row. */
public static class RowBuilder {
private final List<String> lines = new ArrayList<>();
// Minimum number of lines so that you can be sure a solver was added
private static final int MIN_NUM_OF_LINES = 4;
private static final int SOLVER_COLUMN_WIDTH = 11;
private static final int VERSION_COLUMN_WIDTH = 38;
private static final int THEORIES_COLUMN_WIDTH = 30;
private static final int FEATURES_COLUMN_WIDTH = 30;
private static final String INFO_COLUMN =
"| %-"
+ SOLVER_COLUMN_WIDTH
+ "s | %-"
+ VERSION_COLUMN_WIDTH
+ "s | %-"
+ THEORIES_COLUMN_WIDTH
+ "s | %-"
+ FEATURES_COLUMN_WIDTH
+ "s |%n";
private static final String SEPERATOR_LINE =
"+-"
+ "-".repeat(SOLVER_COLUMN_WIDTH)
+ "-+-"
+ "-".repeat(VERSION_COLUMN_WIDTH)
+ "-+-"
+ "-".repeat(THEORIES_COLUMN_WIDTH)
+ "-+-"
+ "-".repeat(FEATURES_COLUMN_WIDTH)
+ "-+"
+ System.lineSeparator();
/** The constructor builds the header of the table. */
public RowBuilder() {
lines.add(SEPERATOR_LINE);
lines.add(String.format(INFO_COLUMN, "Solver", "Version", "Theories", "Features"));
lines.add(SEPERATOR_LINE);
}
/**
* Takes a SolverInfo object and splits it into multiple lines which are added to the row.
*
* @param solverInfo the solver with information you want added.
*/
public void addSolver(SolverInfo solverInfo) {
List<String> nameLines = Lists.newArrayList(solverInfo.getName());
List<String> versionLines = formatLines(solverInfo.getVersion(), VERSION_COLUMN_WIDTH);
List<String> theoriesLines = formatLines(solverInfo.getTheories(), THEORIES_COLUMN_WIDTH);
List<String> featuresLines = formatLines(solverInfo.getFeatures(), FEATURES_COLUMN_WIDTH);
int maxLines =
Math.max(Math.max(versionLines.size(), theoriesLines.size()), featuresLines.size());
// add empty lines where needed for the layout
padLines(nameLines, maxLines);
padLines(versionLines, maxLines);
padLines(theoriesLines, maxLines);
padLines(featuresLines, maxLines);
// build the full lines for this row
for (int i = 0; i < maxLines; i++) {
String nameL = nameLines.get(i);
String versionL = versionLines.get(i);
String theoriesL = theoriesLines.get(i);
String featuresL = featuresLines.get(i);
lines.add(String.format(INFO_COLUMN, nameL, versionL, theoriesL, featuresL));
}
lines.add(SEPERATOR_LINE);
}
/** Add as many empty lines as needed to fulfill the amount of lines. */
private void padLines(List<String> linesToPad, int amountOfLines) {
int numMissingLines = amountOfLines - linesToPad.size();
for (int i = 0; i < numMissingLines; i++) {
linesToPad.add("");
}
}
/** split a String into multiple lines where each is shorter than the given maxLength. */
private List<String> formatLines(String lineToSplit, int maxLength) {
List<String> versionSplit = Splitter.on(" ").splitToList(lineToSplit);
List<String> versionLines = new ArrayList<>();
String line = versionSplit.get(0);
int lineCounter = line.length();
for (String current : Iterables.skip(versionSplit, 1)) {
lineCounter += current.length() + 1;
if (lineCounter > maxLength) {
lineCounter = current.length() + 1;
versionLines.add(line);
line = current;
} else {
line = line + " " + current;
}
}
versionLines.add(line);
return versionLines;
}
@Override
public String toString() {
if (lines.size() < MIN_NUM_OF_LINES - 1) {
return "Could not find any installed SMT-Solvers.";
}
return String.join("", lines);
}
}
}
| 13,131 | 36.413105 | 105 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/example/Sudoku.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: Unlicense OR Apache-2.0 OR MIT
package org.sosy_lab.java_smt.example;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
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.log.BasicLogManager;
import org.sosy_lab.common.log.LogManager;
import org.sosy_lab.java_smt.SolverContextFactory;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.BooleanFormulaManager;
import org.sosy_lab.java_smt.api.EnumerationFormula;
import org.sosy_lab.java_smt.api.EnumerationFormulaManager;
import org.sosy_lab.java_smt.api.FormulaType.EnumerationFormulaType;
import org.sosy_lab.java_smt.api.IntegerFormulaManager;
import org.sosy_lab.java_smt.api.Model;
import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
import org.sosy_lab.java_smt.api.ProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
/**
* This program parses user-given Sudoku and solves it with an SMT solver.
*
* <p>This program is just an example and provides several distinct strategies for encoding the
* Sudoku problem as SMT. Clearly SMT is not the best solution for solving Sudoku. There might be
* other algorithms out there that are specialized and better suited for solving Sudoku.
*
* <p>Our strategies:
*
* <ul>
* <li>Integer-based: We encode all values as integer formulas for a range from 1 to 9. Straight
* forward, simple to understand, but slow.
* <li>Enumeration-based: We encode all values as enumeration formulas for enumeration values from
* ONE to NINE. Reasonable fast (up to 10x faster than integer-based strategy).
* <li>Boolean-based: We use one more dimension to encode values for the 2D-grid and a
* one-hot-encoding. Fastest SMT-based solution, because it is purely based on SAT, and no
* additional SMT theory is applied.
* </ul>
*
* <p>The more numbers are available in a Sudoku, the easier it can be solved. A completely empty
* Sudoku will cause the longest runtime in the solver, because it will guess a lot of values.
*
* <p>The Sudoku is read from StdIn and should be formatted as the following example:
*
* <pre>
* 2..9.6..1
* ..6.4...9
* ...52.4..
* 3.2..7.5.
* ...2..1..
* .9.3..7..
* .87.5.31.
* 6.3.1.8..
* 4....9...
* </pre>
*
* <p>The solution will then be printed on StdOut, just like the following solution:
*
* <pre>
* 248976531
* 536148279
* 179523468
* 312487956
* 764295183
* 895361742
* 987652314
* 623714895
* 451839627
* </pre>
*/
@SuppressWarnings("unused")
public class Sudoku {
public static final int SIZE = 9;
private static final int BLOCKSIZE = 3;
private static final Integer[][] UNSOLVABLE_SUDOKU = null;
public static void main(String... args)
throws InvalidConfigurationException, SolverException, InterruptedException, IOException {
Configuration config = Configuration.defaultConfiguration();
LogManager logger = BasicLogManager.create(config);
ShutdownNotifier notifier = ShutdownNotifier.createDummy();
// for (Solvers solver : Solvers.values()) {
{
Solvers solver = Solvers.Z3;
try (SolverContext context =
SolverContextFactory.createSolverContext(config, logger, notifier, solver)) {
Integer[][] grid = readGridFromStdin();
for (SudokuSolver<?> sudoku :
List.of(
new IntegerBasedSudokuSolver(context),
new EnumerationBasedSudokuSolver(context),
new BooleanBasedSudokuSolver(context))) {
long start = System.currentTimeMillis();
Integer[][] solution = sudoku.solve(grid);
if (solution == UNSOLVABLE_SUDOKU) {
System.out.println("Sudoku has no solution.");
} else {
System.out.println("Sudoku has a solution:");
for (Integer[] line : solution) {
System.out.println(Joiner.on("").join(line));
}
}
long end = System.currentTimeMillis();
System.out.println(" Used strategy: " + sudoku.getClass().getSimpleName());
System.out.println(" Time to solve: " + (end - start) + " ms");
}
} catch (InvalidConfigurationException | UnsatisfiedLinkError e) {
// on some machines we support only some solvers,
// thus we can ignore these errors.
logger.logUserException(Level.INFO, e, "Solver " + solver + " is not available.");
} catch (UnsupportedOperationException e) {
logger.logUserException(Level.INFO, e, e.getMessage());
}
}
}
private Sudoku() {}
/**
* a simple parser for a half-filled Sudoku.
*
* <p>Use digits 0-9 as values, other values will be set to 'unknown'.
*/
private static Integer[][] readGridFromStdin() {
Integer[][] grid = new Integer[SIZE][SIZE];
System.out.println("Insert Sudoku:");
@SuppressWarnings("resource") // closing Scanner will close StdIn, and we do not want this
Scanner s = new Scanner(System.in, Charset.defaultCharset().name());
for (int row = 0; row < SIZE; row++) {
String line = s.nextLine().trim();
for (int col = 0; col < Math.min(line.length(), SIZE); col++) {
char nextNumber = line.charAt(col);
if ('0' <= nextNumber && nextNumber <= '9') {
grid[row][col] = nextNumber - '0';
}
}
}
return grid;
}
public abstract static class SudokuSolver<S> {
private final SolverContext context;
final BooleanFormulaManager bmgr;
final IntegerFormulaManager imgr;
private SudokuSolver(SolverContext pContext) {
context = pContext;
bmgr = context.getFormulaManager().getBooleanFormulaManager();
imgr = context.getFormulaManager().getIntegerFormulaManager();
}
abstract S getSymbols();
abstract List<BooleanFormula> getRules(S symbols);
/** convert the user-given values into constraints for the solver. */
private List<BooleanFormula> getAssignments(S symbols, Integer[][] grid) {
final List<BooleanFormula> assignments = new ArrayList<>();
for (int row = 0; row < SIZE; row++) {
for (int col = 0; col < SIZE; col++) {
Integer value = grid[row][col];
if (value != null) {
assignments.add(getAssignment(symbols, row, col, value));
}
}
}
return assignments;
}
/** convert one user-given value at given coordinate into a constraint for the solver. */
abstract BooleanFormula getAssignment(S symbols, int row, int col, Integer value);
abstract Integer getValue(S symbols, Model model, int row, int col);
/**
* Solves a sudoku using the given grid values and returns a possible solution. Return <code>
* Null
* </code> if Sudoku cannot be solved.
*/
@Nullable
public Integer[][] solve(Integer[][] grid) throws InterruptedException, SolverException {
S symbols = getSymbols();
List<BooleanFormula> rules = getRules(symbols);
List<BooleanFormula> assignments = getAssignments(symbols, grid);
// solve Sudoku
try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) {
prover.push(bmgr.and(rules));
prover.push(bmgr.and(assignments));
boolean isUnsolvable = prover.isUnsat(); // the hard part
if (isUnsolvable) {
return UNSOLVABLE_SUDOKU;
}
// get model and convert it
Integer[][] solution = new Integer[SIZE][SIZE];
try (Model model = prover.getModel()) {
for (int row = 0; row < SIZE; row++) {
for (int col = 0; col < SIZE; col++) {
solution[row][col] = getValue(symbols, model, row, col);
}
}
}
return solution;
}
}
}
public static class IntegerBasedSudokuSolver extends SudokuSolver<IntegerFormula[][]> {
public IntegerBasedSudokuSolver(SolverContext context) {
super(context);
}
/** prepare symbols: one symbol for each of the 9x9 cells. */
@Override
IntegerFormula[][] getSymbols() {
final IntegerFormula[][] symbols = new IntegerFormula[SIZE][SIZE];
for (int row = 0; row < SIZE; row++) {
for (int col = 0; col < SIZE; col++) {
symbols[row][col] = imgr.makeVariable("xi_" + row + "_" + col);
}
}
return symbols;
}
/**
* build the default Sudoku constraints:
* <li>each symbol has a value from 1 to 9.
* <li>each column, each row, and each 3x3 block contains 9 distinct integer values.
*/
@Override
List<BooleanFormula> getRules(IntegerFormula[][] symbols) {
final List<BooleanFormula> rules = new ArrayList<>();
// each symbol has a value from 1 to 9
IntegerFormula one = imgr.makeNumber(1);
IntegerFormula nine = imgr.makeNumber(9);
for (int row = 0; row < SIZE; row++) {
for (int col = 0; col < SIZE; col++) {
for (int i = 0; i < SIZE; i++) {
rules.add(imgr.lessOrEquals(one, symbols[row][col]));
rules.add(imgr.lessOrEquals(symbols[row][col], nine));
}
}
}
// row constraints: distinct numbers in all rows
for (int row = 0; row < SIZE; row++) {
List<IntegerFormula> lst = new ArrayList<>();
for (int col = 0; col < SIZE; col++) {
lst.add(symbols[row][col]);
}
rules.add(imgr.distinct(lst));
}
// column constraints: distinct numbers in all columns
for (int col = 0; col < SIZE; col++) {
List<IntegerFormula> lst = new ArrayList<>();
for (int row = 0; row < SIZE; row++) {
lst.add(symbols[row][col]);
}
rules.add(imgr.distinct(lst));
}
// block constraints: distinct numbers in all 3x3 blocks
for (int rowB = 0; rowB < SIZE; rowB += BLOCKSIZE) {
for (int colB = 0; colB < SIZE; colB += BLOCKSIZE) {
List<IntegerFormula> lst = new ArrayList<>();
for (int row = rowB; row < rowB + BLOCKSIZE; row++) {
for (int col = colB; col < colB + BLOCKSIZE; col++) {
lst.add(symbols[row][col]);
}
}
rules.add(imgr.distinct(lst));
}
}
return rules;
}
@Override
BooleanFormula getAssignment(IntegerFormula[][] symbols, int row, int col, Integer value) {
return imgr.equal(symbols[row][col], imgr.makeNumber(value));
}
@Override
Integer getValue(IntegerFormula[][] symbols, Model model, int row, int col) {
return model.evaluate(symbols[row][col]).intValue();
}
}
public static class BooleanBasedSudokuSolver extends SudokuSolver<BooleanFormula[][][]> {
public BooleanBasedSudokuSolver(SolverContext context) {
super(context);
}
/** prepare symbols: one symbol for each of the 9x9 cells. */
@Override
BooleanFormula[][][] getSymbols() {
final BooleanFormula[][][] symbols = new BooleanFormula[SIZE][SIZE][SIZE];
for (int row = 0; row < SIZE; row++) {
for (int col = 0; col < SIZE; col++) {
for (int value = 0; value < SIZE; value++) {
symbols[row][col][value] = bmgr.makeVariable("xb_" + row + "_" + col + "_" + value);
}
}
}
return symbols;
}
/**
* build the default Sudoku constraints:
* <li>each symbol has a value from 1 to 9.
* <li>each column, each row, and each 3x3 block contains 9 distinct integer values.
*/
@Override
List<BooleanFormula> getRules(BooleanFormula[][][] symbols) {
final List<BooleanFormula> rules = new ArrayList<>();
// each symbol has a value from 1 to 9
for (int row = 0; row < SIZE; row++) {
for (int col = 0; col < SIZE; col++) {
rules.add(oneHot(ImmutableList.copyOf(symbols[row][col])));
}
}
// row constraints: distinct numbers in all rows
for (int row = 0; row < SIZE; row++) {
for (int value = 0; value < SIZE; value++) {
List<BooleanFormula> lst = new ArrayList<>();
for (int col = 0; col < SIZE; col++) {
lst.add(symbols[row][col][value]);
}
rules.add(oneHot(lst));
}
}
// column constraints: distinct numbers in all columns
for (int col = 0; col < SIZE; col++) {
for (int value = 0; value < SIZE; value++) {
List<BooleanFormula> lst = new ArrayList<>();
for (int row = 0; row < SIZE; row++) {
lst.add(symbols[row][col][value]);
}
rules.add(oneHot(lst));
}
}
// block constraints: distinct numbers in all 3x3 blocks
for (int rowB = 0; rowB < SIZE; rowB += BLOCKSIZE) {
for (int colB = 0; colB < SIZE; colB += BLOCKSIZE) {
for (int value = 0; value < SIZE; value++) {
List<BooleanFormula> lst = new ArrayList<>();
for (int row = rowB; row < rowB + BLOCKSIZE; row++) {
for (int col = colB; col < colB + BLOCKSIZE; col++) {
lst.add(symbols[row][col][value]);
}
}
rules.add(oneHot(lst));
}
}
}
return rules;
}
/** exactly one of the variables must be true, the rest must be false. */
private BooleanFormula oneHot(List<BooleanFormula> vars) {
List<BooleanFormula> oneHot = new ArrayList<>();
for (int i = 0; i < SIZE; i++) {
for (int j = 0; j < i; j++) {
oneHot.add(bmgr.not(bmgr.and(vars.get(i), vars.get(j))));
}
}
oneHot.add(bmgr.or(vars));
return bmgr.and(oneHot);
}
@Override
BooleanFormula getAssignment(BooleanFormula[][][] symbols, int row, int col, Integer value) {
return symbols[row][col][value - 1]; // off-by-one!
}
@Override
Integer getValue(BooleanFormula[][][] symbols, Model model, int row, int col) {
for (int value = 0; value < SIZE; value++) {
if (model.evaluate(symbols[row][col][value])) {
return value + 1; // off-by-one!
}
}
return null;
}
}
public static class EnumerationBasedSudokuSolver extends SudokuSolver<EnumerationFormula[][]> {
private final EnumerationFormulaManager emgr;
private final EnumerationFormulaType type;
private static final String[] VALUES = {
"ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE",
};
public EnumerationBasedSudokuSolver(SolverContext context) {
super(context);
emgr = context.getFormulaManager().getEnumerationFormulaManager();
type = emgr.declareEnumeration("VALUES", VALUES);
}
/** prepare symbols: one symbol for each of the 9x9 cells. */
@Override
EnumerationFormula[][] getSymbols() {
final EnumerationFormula[][] symbols = new EnumerationFormula[SIZE][SIZE];
for (int row = 0; row < SIZE; row++) {
for (int col = 0; col < SIZE; col++) {
symbols[row][col] = emgr.makeVariable("xe_" + row + "_" + col, type);
}
}
return symbols;
}
/**
* build the default Sudoku constraints:
* <li>each symbol has a value from 1 to 9.
* <li>each column, each row, and each 3x3 block contains 9 distinct integer values.
*/
@Override
List<BooleanFormula> getRules(EnumerationFormula[][] symbols) {
final List<BooleanFormula> rules = new ArrayList<>();
// each symbol has a value from 1 to 9
// -> solved implicitly by using enum-type
// row constraints: distinct numbers in all rows
for (int row = 0; row < SIZE; row++) {
List<EnumerationFormula> lst = new ArrayList<>();
for (int col = 0; col < SIZE; col++) {
lst.add(symbols[row][col]);
}
rules.add(distinct(lst));
}
// column constraints: distinct numbers in all columns
for (int col = 0; col < SIZE; col++) {
List<EnumerationFormula> lst = new ArrayList<>();
for (int row = 0; row < SIZE; row++) {
lst.add(symbols[row][col]);
}
rules.add(distinct(lst));
}
// block constraints: distinct numbers in all 3x3 blocks
for (int rowB = 0; rowB < SIZE; rowB += BLOCKSIZE) {
for (int colB = 0; colB < SIZE; colB += BLOCKSIZE) {
List<EnumerationFormula> lst = new ArrayList<>();
for (int row = rowB; row < rowB + BLOCKSIZE; row++) {
for (int col = colB; col < colB + BLOCKSIZE; col++) {
lst.add(symbols[row][col]);
}
}
rules.add(distinct(lst));
}
}
return rules;
}
private BooleanFormula distinct(List<EnumerationFormula> lst) {
if (lst.size() <= 1) {
return bmgr.makeTrue();
} else {
List<BooleanFormula> pairings = new ArrayList<>();
for (int i = 0; i < lst.size(); i++) {
for (int j = 0; j < i; j++) {
pairings.add(bmgr.not(emgr.equivalence(lst.get(i), lst.get(j))));
}
}
return bmgr.and(pairings);
}
}
@Override
BooleanFormula getAssignment(EnumerationFormula[][] symbols, int row, int col, Integer value) {
// index-shift required
return emgr.equivalence(symbols[row][col], emgr.makeConstant(VALUES[value - 1], type));
}
@Override
Integer getValue(EnumerationFormula[][] symbols, Model model, int row, int col) {
String value = model.evaluate(symbols[row][col]);
for (int i = 0; i < VALUES.length; i++) {
if (VALUES[i].equals(value)) {
return i + 1; // index-shift required
}
}
return null;
}
}
}
| 18,467 | 33.911153 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/example/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: Unlicense OR Apache-2.0 OR MIT
/** Some basic examples for using Java-SMT. */
package org.sosy_lab.java_smt.example;
| 346 | 30.545455 | 69 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/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
/** Solver-specific backends. */
package org.sosy_lab.java_smt.solvers;
| 312 | 27.454545 | 69 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorAbstractProver.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.boolector;
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 java.util.concurrent.atomic.AtomicBoolean;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.Model;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
import org.sosy_lab.java_smt.api.SolverException;
import org.sosy_lab.java_smt.basicimpl.AbstractProverWithAllSat;
import org.sosy_lab.java_smt.basicimpl.CachingModel;
import org.sosy_lab.java_smt.solvers.boolector.BtorJNI.TerminationCallback;
abstract class BoolectorAbstractProver<T> extends AbstractProverWithAllSat<T> {
// BoolectorAbstractProver<E, AF> extends AbstractProverWithAllSat<E>
// AF = assertedFormulas; E = ?
/** Boolector does not support multiple solver stacks. */
private final AtomicBoolean isAnyStackAlive;
private final long btor;
private final BoolectorFormulaManager manager;
private final BoolectorFormulaCreator creator;
protected final Deque<List<Long>> assertedFormulas = new ArrayDeque<>();
protected boolean wasLastSatCheckSat = false; // and stack is not changed
private final TerminationCallback terminationCallback;
private final long terminationCallbackHelper;
// Used/Built by TheoremProver
protected BoolectorAbstractProver(
BoolectorFormulaManager manager,
BoolectorFormulaCreator creator,
long btor,
ShutdownNotifier pShutdownNotifier,
Set<ProverOptions> pOptions,
AtomicBoolean pIsAnyStackAlive) {
super(pOptions, manager.getBooleanFormulaManager(), pShutdownNotifier);
this.manager = manager;
this.creator = creator;
this.btor = btor;
terminationCallback = shutdownNotifier::shouldShutdown;
terminationCallbackHelper = addTerminationCallback();
isAnyStackAlive = pIsAnyStackAlive;
// avoid dual stack usage
Preconditions.checkState(
!isAnyStackAlive.getAndSet(true),
"Boolector does not support the usage of multiple "
+ "solver stacks at the same time. Please close any existing solver stack.");
// push an initial level, required for cleaning up later (see #close), for reusage of Boolector.
push();
}
@Override
public void close() {
if (!closed) {
// Free resources of callback
BtorJNI.boolector_free_termination(terminationCallbackHelper);
// remove the whole stack, including the initial level from the constructor call.
BtorJNI.boolector_pop(manager.getEnvironment(), assertedFormulas.size());
assertedFormulas.clear();
// You can't use delete here because you wouldn't be able to access model
// Wait till we have visitor/toList, after that we can delete here
// BtorJNI.boolector_delete(btor);
closed = true;
Preconditions.checkState(isAnyStackAlive.getAndSet(false));
}
}
/*
* Boolector should throw its own exceptions that tell you what went wrong!
*/
@Override
public boolean isUnsat() throws SolverException, InterruptedException {
Preconditions.checkState(!closed);
wasLastSatCheckSat = false;
final int result = BtorJNI.boolector_sat(btor);
if (result == BtorJNI.BTOR_RESULT_SAT_get()) {
wasLastSatCheckSat = true;
return false;
} else if (result == BtorJNI.BTOR_RESULT_UNSAT_get()) {
return true;
} else if (result == BtorJNI.BTOR_RESULT_UNKNOWN_get()) {
if (BtorJNI.boolector_terminate(btor) == 0) {
throw new SolverException(
"Boolector has encountered a problem or ran out of stack or heap memory, "
+ "try increasing their sizes.");
} else {
throw new InterruptedException("Boolector was terminated via ShutdownManager.");
}
} else {
throw new SolverException("Boolector sat call returned " + result);
}
}
@Override
public void pop() {
Preconditions.checkState(!closed);
Preconditions.checkState(size() > 0);
assertedFormulas.pop();
BtorJNI.boolector_pop(manager.getEnvironment(), 1);
}
@Override
public void push() {
Preconditions.checkState(!closed);
assertedFormulas.push(new ArrayList<>());
BtorJNI.boolector_push(manager.getEnvironment(), 1);
}
@Override
public int size() {
Preconditions.checkState(!closed);
return assertedFormulas.size() - 1;
}
@Override
public boolean isUnsatWithAssumptions(Collection<BooleanFormula> pAssumptions)
throws SolverException, InterruptedException {
Preconditions.checkState(!closed);
for (BooleanFormula assumption : pAssumptions) {
BtorJNI.boolector_assume(btor, BoolectorFormulaManager.getBtorTerm(assumption));
}
return isUnsat();
}
@SuppressWarnings("resource")
@Override
public Model getModel() throws SolverException {
Preconditions.checkState(!closed);
Preconditions.checkState(wasLastSatCheckSat, NO_MODEL_HELP);
checkGenerateModels();
return new CachingModel(getEvaluatorWithoutChecks());
}
@Override
protected BoolectorModel getEvaluatorWithoutChecks() {
return new BoolectorModel(btor, creator, this, getAssertedTerms());
}
@Override
public List<BooleanFormula> getUnsatCore() {
throw new UnsupportedOperationException("Unsat core is not supported by Boolector.");
}
@Override
public Optional<List<BooleanFormula>> unsatCoreOverAssumptions(
Collection<BooleanFormula> pAssumptions) throws SolverException, InterruptedException {
throw new UnsupportedOperationException(
"Unsat core with assumptions is not supported by Boolector.");
}
@Override
@Nullable
public T addConstraint(BooleanFormula constraint) {
BtorJNI.boolector_assert(
manager.getEnvironment(), BoolectorFormulaManager.getBtorTerm(constraint));
assertedFormulas.peek().add(BoolectorFormulaManager.getBtorTerm(constraint));
return null;
}
protected Collection<Long> getAssertedTerms() {
List<Long> result = new ArrayList<>();
assertedFormulas.forEach(result::addAll);
return result;
}
/**
* Simply returns true if the prover is closed. False otherwise.
*
* @return bool return value.
*/
protected boolean isClosed() {
return closed;
}
private long addTerminationCallback() {
Preconditions.checkState(!closed, "solver context is already closed");
return BtorJNI.boolector_set_termination(btor, terminationCallback);
}
}
| 6,911 | 33.909091 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorArrayFormulaManager.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.boolector;
import static com.google.common.base.Preconditions.checkArgument;
import com.google.common.collect.Table;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.FormulaType.BitvectorType;
import org.sosy_lab.java_smt.basicimpl.AbstractArrayFormulaManager;
public class BoolectorArrayFormulaManager
extends AbstractArrayFormulaManager<Long, Long, Long, Long> {
private final long btor;
private final Table<String, Long, Long> nameFormulaCache;
BoolectorArrayFormulaManager(BoolectorFormulaCreator pCreator) {
super(pCreator);
this.btor = pCreator.getEnv();
this.nameFormulaCache = pCreator.getCache();
}
// pIndex should be a bitVector
@Override
protected Long select(Long pArray, Long pIndex) {
return BtorJNI.boolector_read(btor, pArray, pIndex);
}
// pIndex and pValue should be bitVectors
@Override
protected Long store(Long pArray, Long pIndex, Long pValue) {
return BtorJNI.boolector_write(btor, pArray, pIndex, pValue);
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TI extends Formula, TE extends Formula> Long internalMakeArray(
String name, FormulaType<TI> pIndexType, FormulaType<TE> pElementType) {
checkArgument(
pIndexType.isBitvectorType() && pElementType.isBitvectorType(),
"Boolector supports bitvector arrays only.");
BitvectorType indexType = (BitvectorType) pIndexType;
BitvectorType elementType = (BitvectorType) pElementType;
final long indexSort = BtorJNI.boolector_bitvec_sort(btor, indexType.getSize());
final long elementSort = BtorJNI.boolector_bitvec_sort(btor, elementType.getSize());
final long arraySort = BtorJNI.boolector_array_sort(btor, indexSort, elementSort);
Long maybeFormula = nameFormulaCache.get(name, arraySort);
if (maybeFormula != null) {
return maybeFormula;
}
if (nameFormulaCache.containsRow(name)) {
throw new IllegalArgumentException("Symbol already used: " + name);
}
final long array = BtorJNI.boolector_array(btor, arraySort, name);
nameFormulaCache.put(name, arraySort, array);
return array;
}
@Override
protected Long equivalence(Long pArray1, Long pArray2) {
return BtorJNI.boolector_eq(btor, pArray1, pArray2);
}
}
| 2,612 | 35.291667 | 88 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorBitvectorFormulaManager.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.boolector;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_add;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_and;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_concat;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_eq;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_mul;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_neg;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_not;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_or;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sdiv;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sext;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sgt;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sgte;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sll;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_slt;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_slte;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sra;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_srem;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_srl;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sub;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_udiv;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_uext;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_ugt;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_ugte;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_ult;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_ulte;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_urem;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_xor;
import java.math.BigInteger;
import org.sosy_lab.java_smt.basicimpl.AbstractBitvectorFormulaManager;
class BoolectorBitvectorFormulaManager
extends AbstractBitvectorFormulaManager<Long, Long, Long, Long> {
private final long btor;
BoolectorBitvectorFormulaManager(
BoolectorFormulaCreator creator, BoolectorBooleanFormulaManager pBmgr) {
super(creator, pBmgr);
this.btor = creator.getEnv();
}
@Override
public Long makeBitvectorImpl(int pLength, BigInteger pI) {
pI = transformValueToRange(pLength, pI);
long sort = BtorJNI.boolector_bitvec_sort(btor, pLength);
return BtorJNI.boolector_constd(btor, sort, pI.toString());
}
@Override
protected Long makeBitvectorImpl(int length, Long value) {
// The value is a pointer to an expression. Do not use the plain numberal value.
throw new UnsupportedOperationException("Boolector does not support INT theory");
}
@Override
public Long toIntegerFormulaImpl(Long pI, boolean pSigned) {
throw new UnsupportedOperationException("BV to INT conversion is not supported.");
}
@Override
public Long negate(Long bitVec) {
return boolector_neg(btor, bitVec);
}
@Override
public Long add(Long bitVec1, Long bitVec2) {
return boolector_add(btor, bitVec1, bitVec2);
}
@Override
public Long subtract(Long bitVec1, Long bitVec2) {
return boolector_sub(btor, bitVec1, bitVec2);
}
@Override
public Long divide(Long bitVec1, Long bitVec2, boolean signed) {
if (signed) {
return boolector_sdiv(btor, bitVec1, bitVec2);
} else {
return boolector_udiv(btor, bitVec1, bitVec2);
}
}
@Override
public Long modulo(Long bitVec1, Long bitVec2, boolean signed) {
if (signed) {
return boolector_srem(btor, bitVec1, bitVec2);
} else {
return boolector_urem(btor, bitVec1, bitVec2);
}
}
@Override
public Long multiply(Long bitVec1, Long bitVec2) {
return boolector_mul(btor, bitVec1, bitVec2);
}
@Override
public Long equal(Long bitVec1, Long bitVec2) {
return boolector_eq(btor, bitVec1, bitVec2);
}
@Override
public Long greaterThan(Long bitVec1, Long bitVec2, boolean signed) {
if (signed) {
return boolector_sgt(btor, bitVec1, bitVec2);
} else {
return boolector_ugt(btor, bitVec1, bitVec2);
}
}
@Override
public Long greaterOrEquals(Long bitVec1, Long bitVec2, boolean signed) {
if (signed) {
return boolector_sgte(btor, bitVec1, bitVec2);
} else {
return boolector_ugte(btor, bitVec1, bitVec2);
}
}
@Override
public Long lessThan(Long bitVec1, Long bitVec2, boolean signed) {
if (signed) {
return boolector_slt(btor, bitVec1, bitVec2);
} else {
return boolector_ult(btor, bitVec1, bitVec2);
}
}
@Override
public Long lessOrEquals(Long bitVec1, Long bitVec2, boolean signed) {
if (signed) {
return boolector_slte(btor, bitVec1, bitVec2);
} else {
return boolector_ulte(btor, bitVec1, bitVec2);
}
}
@Override
public Long not(Long bitVec) {
return boolector_not(btor, bitVec);
}
@Override
public Long and(Long bitVec1, Long bitVec2) {
return boolector_and(btor, bitVec1, bitVec2);
}
@Override
public Long or(Long bitVec1, Long bitVec2) {
return boolector_or(btor, bitVec1, bitVec2);
}
@Override
public Long xor(Long bitVec1, Long bitVec2) {
return boolector_xor(btor, bitVec1, bitVec2);
}
@Override
public Long makeVariableImpl(int pLength, String pVar) {
long sort = BtorJNI.boolector_bitvec_sort(btor, pLength);
return getFormulaCreator().makeVariable(sort, pVar);
}
@Override
public Long shiftRight(Long bitVec, Long toShift, boolean signed) {
if (signed) {
return boolector_sra(btor, bitVec, toShift);
} else {
return boolector_srl(btor, bitVec, toShift);
}
}
@Override
public Long shiftLeft(Long bitVec, Long toShift) {
return boolector_sll(btor, bitVec, toShift);
}
@Override
public Long concat(Long bitVec, Long bitVecAppend) {
return boolector_concat(btor, bitVec, bitVecAppend);
}
@Override
public Long extract(Long pNode, int pMsb, int pLsb) {
return BtorJNI.boolector_slice(btor, pNode, pMsb, pLsb);
}
@Override
public Long extend(Long bitVec, int extensionBits, boolean signed) {
if (signed) {
return boolector_sext(btor, bitVec, extensionBits);
} else {
return boolector_uext(btor, bitVec, extensionBits);
}
}
}
| 6,890 | 31.971292 | 86 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorBooleanFormulaManager.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.boolector;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_and;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_cond;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_false;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_iff;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_not;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_or;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_true;
import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_xor;
import com.google.common.primitives.Longs;
import org.sosy_lab.java_smt.basicimpl.AbstractBooleanFormulaManager;
public class BoolectorBooleanFormulaManager
extends AbstractBooleanFormulaManager<Long, Long, Long, Long> {
private final long btor;
private final long pTrue;
private final long pFalse;
BoolectorBooleanFormulaManager(BoolectorFormulaCreator pCreator) {
super(pCreator);
this.btor = pCreator.getEnv();
pTrue = boolector_true(btor);
pFalse = boolector_false(btor);
}
@Override
public Long makeVariableImpl(String varName) {
long boolType = getFormulaCreator().getBoolType();
return getFormulaCreator().makeVariable(boolType, varName);
}
@Override
public Long makeBooleanImpl(boolean pValue) {
return pValue ? pTrue : pFalse;
}
@Override
public Long not(Long pParam1) {
return boolector_not(btor, pParam1);
}
@Override
public Long and(Long pParam1, Long pParam2) {
if (isTrue(pParam1)) {
return pParam2;
} else if (isTrue(pParam2)) {
return pParam1;
} else if (isFalse(pParam1)) {
return pFalse;
} else if (isFalse(pParam2)) {
return pFalse;
} else if (pParam1.equals(pParam2)) {
return pParam1;
}
return boolector_and(btor, pParam1, pParam2);
}
@Override
public Long or(Long pParam1, Long pParam2) {
if (isTrue(pParam1)) {
return pTrue;
} else if (isTrue(pParam2)) {
return pTrue;
} else if (isFalse(pParam1)) {
return pParam2;
} else if (isFalse(pParam2)) {
return pParam1;
} else if (pParam1.equals(pParam2)) {
return pParam1;
}
return boolector_or(btor, pParam1, pParam2);
}
@Override
public Long xor(Long pParam1, Long pParam2) {
return boolector_xor(btor, pParam1, pParam2);
}
@Override
public Long equivalence(Long pBits1, Long pBits2) {
return boolector_iff(btor, pBits1, pBits2);
}
@Override
public boolean isTrue(Long pBits) {
return isConstant(pBits, 1);
}
@Override
public boolean isFalse(Long pBits) {
return isConstant(pBits, 0);
}
private boolean isConstant(final long pBits, final int constant) {
if (BtorJNI.boolector_get_width(btor, pBits) == 1) {
String assignment;
if (BtorJNI.boolector_is_const(btor, pBits)) {
assignment = BtorJNI.boolector_get_bits(btor, pBits);
Long maybeLong = Longs.tryParse(assignment);
if (maybeLong != null && maybeLong == constant) {
return true;
}
}
}
return false;
}
@Override
public 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 boolector_cond(btor, pCond, pF1, pF2);
}
}
| 3,874 | 27.703704 | 78 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorFormula.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.boolector;
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.Formula;
import org.sosy_lab.java_smt.api.FormulaType;
@Immutable
abstract class BoolectorFormula implements Formula {
private final long btorTerm;
private final long btor; // We need the boolector instance to calculate the hash
BoolectorFormula(long term, long btor) {
this.btorTerm = term;
this.btor = btor;
}
final long getTerm() {
return btorTerm;
}
@Override
public final boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof BoolectorFormula)) {
return false;
}
BoolectorFormula other = (BoolectorFormula) o;
return btor == other.btor && btorTerm == other.btorTerm;
}
@Override
public final int hashCode() {
// Boolector uses structural hashing on its nodes (formulas)
return BtorJNI.boolector_get_node_id(btor, btorTerm);
}
@Immutable
static final class BoolectorBitvectorFormula extends BoolectorFormula
implements BitvectorFormula {
BoolectorBitvectorFormula(long pTerm, long btor) {
super(pTerm, btor);
}
}
@Immutable
static final class BoolectorBooleanFormula extends BoolectorFormula implements BooleanFormula {
BoolectorBooleanFormula(long pTerm, long btor) {
super(pTerm, btor);
}
}
@SuppressWarnings("ClassTypeParameterName")
static final class BoolectorArrayFormula<TI extends Formula, TE extends Formula>
extends BoolectorFormula implements ArrayFormula<TI, TE> {
private final FormulaType<TI> indexType;
private final FormulaType<TE> elementType;
BoolectorArrayFormula(
long pTerm, FormulaType<TI> pIndexType, FormulaType<TE> pElementType, long btor) {
super(pTerm, btor);
indexType = pIndexType;
elementType = pElementType;
}
public FormulaType<TI> getIndexType() {
return indexType;
}
public FormulaType<TE> getElementType() {
return elementType;
}
}
}
| 2,440 | 26.426966 | 97 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorFormulaCreator.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.boolector;
import static com.google.common.base.Preconditions.checkArgument;
import com.google.common.base.Preconditions;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Table;
import com.google.common.primitives.Longs;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
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.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.boolector.BoolectorFormula.BoolectorArrayFormula;
import org.sosy_lab.java_smt.solvers.boolector.BoolectorFormula.BoolectorBitvectorFormula;
import org.sosy_lab.java_smt.solvers.boolector.BoolectorFormula.BoolectorBooleanFormula;
public class BoolectorFormulaCreator extends FormulaCreator<Long, Long, Long, Long> {
// Boolector can give back 'x' for an arbitrary value that we change to this
private static final char ARBITRARY_VALUE = '1';
/**
* Maps a name and a variable or function type to a concrete formula node. We allow only 1 type
* per var name, meaning there is only 1 column per row!
*/
private final Table<String, Long, Long> formulaCache = HashBasedTable.create();
// Remember uf sorts, as Boolector does not give them back correctly
private final Map<Long, List<Long>> ufArgumentsSortMap = new HashMap<>();
// Possibly we need to split this up into vars, ufs, and arrays
BoolectorFormulaCreator(Long btor) {
super(btor, BtorJNI.boolector_bool_sort(btor), null, null, null, null);
}
@SuppressWarnings("unchecked")
@Override
public <T extends Formula> FormulaType<T> getFormulaType(T pFormula) {
if (pFormula instanceof BitvectorFormula) {
long sort = BtorJNI.boolector_get_sort(getEnv(), extractInfo(pFormula));
checkArgument(
BtorJNI.boolector_is_bitvec_sort(getEnv(), sort),
"BitvectorFormula with type missmatch: %s",
pFormula);
return (FormulaType<T>)
FormulaType.getBitvectorTypeWithSize(
BtorJNI.boolector_get_width(getEnv(), extractInfo(pFormula)));
} else if (pFormula instanceof ArrayFormula<?, ?>) {
FormulaType<T> arrayIndexType = getArrayFormulaIndexType((ArrayFormula<T, T>) pFormula);
FormulaType<T> arrayElementType = getArrayFormulaElementType((ArrayFormula<T, T>) pFormula);
return (FormulaType<T>) FormulaType.getArrayType(arrayIndexType, arrayElementType);
}
return super.getFormulaType(pFormula);
}
@Override
public Long extractInfo(Formula pT) {
return BoolectorFormulaManager.getBtorTerm(pT);
}
@Override
public FormulaType<?> getFormulaType(Long pFormula) {
long sort = BtorJNI.boolector_get_sort(getEnv(), pFormula);
// Careful, Boolector interprets nearly everything as a fun!
if (!BtorJNI.boolector_is_array_sort(getEnv(), sort)
&& !BtorJNI.boolector_is_bitvec_sort(getEnv(), sort)
&& BtorJNI.boolector_is_fun_sort(getEnv(), sort)) {
sort = BtorJNI.boolector_fun_get_codomain_sort(getEnv(), pFormula);
}
return getFormulaTypeFromSortAndFormula(pFormula, sort);
}
/**
* Returns the proper FormulaType for the sort entered.
*
* @param pFormula Some Boolector node. Either the node of the sort, or its parent. Only has to be
* accurate for arrays.
* @param sort The actual sort you want the FormulaType of.
* @return FormulaType for the sort.
*/
private FormulaType<?> getFormulaTypeFromSortAndFormula(Long pFormula, Long sort) {
if (BtorJNI.boolector_is_array_sort(getEnv(), sort)) {
int indexWidth = BtorJNI.boolector_get_index_width(getEnv(), pFormula);
int elementWidth = BtorJNI.boolector_get_width(getEnv(), pFormula);
return FormulaType.getArrayType(
FormulaType.getBitvectorTypeWithSize(indexWidth),
FormulaType.getBitvectorTypeWithSize(elementWidth));
} else if (BtorJNI.boolector_is_bitvec_sort(getEnv(), sort)) {
int width = BtorJNI.boolector_bitvec_sort_get_width(getEnv(), sort);
if (width == 1) {
return FormulaType.BooleanType;
} else {
return FormulaType.getBitvectorTypeWithSize(width);
}
}
throw new IllegalArgumentException("Unknown formula type for " + pFormula);
}
@SuppressWarnings("unchecked")
@Override
public <T extends Formula> T encapsulate(FormulaType<T> pType, Long pTerm) {
assert pType.equals(getFormulaType(pTerm))
: String.format(
"Trying to encapsulate formula of type %s as %s", getFormulaType(pTerm), pType);
if (pType.isBooleanType()) {
return (T) new BoolectorBooleanFormula(pTerm, getEnv());
} else if (pType.isArrayType()) {
ArrayFormulaType<?, ?> arrFt = (ArrayFormulaType<?, ?>) pType;
return (T)
new BoolectorArrayFormula<>(
pTerm, arrFt.getIndexType(), arrFt.getElementType(), getEnv());
} else if (pType.isBitvectorType()) {
return (T) new BoolectorBitvectorFormula(pTerm, getEnv());
}
throw new IllegalArgumentException(
"Cannot create formulas of type " + pType + " in Boolector.");
}
@Override
public BooleanFormula encapsulateBoolean(Long pTerm) {
assert getFormulaType(pTerm).isBooleanType()
: "Unexpected formula type for Boolean formula: " + getFormulaType(pTerm);
return new BoolectorBooleanFormula(pTerm, getEnv());
}
@Override
public BitvectorFormula encapsulateBitvector(Long pTerm) {
assert getFormulaType(pTerm).isBitvectorType()
: "Unexpected formula type for BV formula: " + getFormulaType(pTerm);
return new BoolectorBitvectorFormula(pTerm, getEnv());
}
@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).isArrayType()
: "Unexpected formula type for array formula: " + getFormulaType(pTerm);
return new BoolectorArrayFormula<>(pTerm, pIndexType, pElementType, getEnv());
}
@Override
public Long getBitvectorType(int pBitwidth) {
return BtorJNI.boolector_bitvec_sort(getEnv(), pBitwidth);
}
@Override
public Long getFloatingPointType(FloatingPointType pType) {
throw new UnsupportedOperationException(
"Boolector does not support floating point operations.");
}
@Override
public Long getArrayType(Long pIndexType, Long pElementType) {
return BtorJNI.boolector_array_sort(getEnv(), pIndexType, pElementType);
}
// Checks if there is a variable with the exact same name and type and gives that back, or a new
// one, potentially with a new internal name (see cache).
@Override
public Long makeVariable(Long type, String varName) {
Long maybeFormula = formulaCache.get(varName, type);
if (maybeFormula != null) {
return maybeFormula;
}
if (formulaCache.containsRow(varName)) {
throw new IllegalArgumentException("Symbol already used: " + varName);
}
long newVar = BtorJNI.boolector_var(getEnv(), type, varName);
formulaCache.put(varName, type, newVar);
return newVar;
}
// This method is a massive problem... you CAN'T get the value formulas(nodes) because they are
// only build and used internally in Boolector. (See visit1 for help)
@Override
public <R> R visit(FormulaVisitor<R> visitor, Formula formula, Long f) {
throw new UnsupportedOperationException(
"Boolector has no methods to access internal nodes for visitation.");
}
// Hopefully a helpful template for when visitor gets implemented
// Btor only has bitvec arrays and ufs with bitvecs and arrays of bitvecs
// (and quantifier with bitvecs only)
@SuppressWarnings("unused")
private <R> R visit1(FormulaVisitor<R> visitor, Formula formula, Long f) {
if (BtorJNI.boolector_is_const(getEnv(), f)) {
// Handles all constants (bitvec, bool)
String bits = BtorJNI.boolector_get_bits(getEnv(), f);
return visitor.visitConstant(formula, convertValue(f, parseBitvector(bits)));
} else if (BtorJNI.boolector_is_param(getEnv(), f)) {
// Quantifier have their own variables called param.
// They can only be bound once! (use them as bitvec)
int deBruijnIdx = 0; // TODO: Ask Developers for this because this is WRONG!
return visitor.visitBoundVariable(formula, deBruijnIdx);
} else if (false) {
// Quantifier
// there is currently no way to find out if the formula is a quantifier
// do we need them separately?
/*
* return visitor .visitQuantifier( (BoolectorBooleanFormula) formula, quantifier,
* boundVariables, new BoolectorBooleanFormula(body, getEnv()));
*/
} else if (BtorJNI.boolector_is_var(getEnv(), f)) {
// bitvec var (size 1 is bool!)
return visitor.visitFreeVariable(formula, getName(f));
} else {
ImmutableList.Builder<Formula> args = ImmutableList.builder();
ImmutableList.Builder<FormulaType<?>> argTypes = ImmutableList.builder();
return visitor.visitFunction(
formula,
args.build(),
FunctionDeclarationImpl.of(
getName(f), getDeclarationKind(f), argTypes.build(), getFormulaType(f), f));
} // TODO: fix declaration in visitFunction
return null;
}
// TODO: returns kind of formula (add, uf etc....) once methods are provided
private FunctionDeclarationKind getDeclarationKind(@SuppressWarnings("unused") long f) {
return null;
}
@Override
public Long callFunctionImpl(Long pDeclaration, List<Long> pArgs) {
Preconditions.checkArgument(
!pArgs.isEmpty(), "Boolector does not support UFs without arguments.");
return BtorJNI.boolector_apply(getEnv(), Longs.toArray(pArgs), pArgs.size(), pDeclaration);
}
@Override
public Long declareUFImpl(String name, Long pReturnType, List<Long> pArgTypes) {
Preconditions.checkArgument(
!pArgTypes.isEmpty(), "Boolector does not support UFs without arguments.");
long[] funSorts = Longs.toArray(pArgTypes);
long sort = BtorJNI.boolector_fun_sort(getEnv(), funSorts, funSorts.length, pReturnType);
Long maybeFormula = formulaCache.get(name, sort);
if (maybeFormula != null) {
return maybeFormula;
}
if (formulaCache.containsRow(name)) {
throw new IllegalArgumentException("Symbol already used: " + name);
}
long uf = BtorJNI.boolector_uf(getEnv(), sort, name);
formulaCache.put(name, sort, uf);
ufArgumentsSortMap.put(uf, pArgTypes);
return uf;
}
@Override
public Object convertValue(Long term) {
String value;
if (BtorJNI.boolector_is_const(getEnv(), term)) {
value = BtorJNI.boolector_get_bits(getEnv(), term);
return transformStringToBigInt(value);
} else if (BtorJNI.boolector_is_bitvec_sort(
getEnv(), BtorJNI.boolector_get_sort(getEnv(), term))) {
value = BtorJNI.boolector_bv_assignment(getEnv(), term);
return transformStringToBigInt(value);
} else if (BtorJNI.boolector_is_fun(getEnv(), term)) {
value = BtorJNI.boolector_uf_assignment_helper(getEnv(), term)[1][0];
return transformStringToBigInt(value);
} else if (BtorJNI.boolector_is_array(getEnv(), term)) {
List<Object> arrayValues = new ArrayList<>();
for (String stringArrayEntry : BtorJNI.boolector_array_assignment_helper(getEnv(), term)[1]) {
arrayValues.add(transformStringToBigInt(stringArrayEntry));
}
return arrayValues;
}
throw new AssertionError("unknown sort and term");
}
protected Object transformStringToBigInt(String value) {
// To get the correct type, we check the width of the term (== 1 means bool).
int width = value.length();
if (width == 1) {
long longValue = parseBigInt(value).longValue();
if (longValue == 1) {
return true;
} else if (longValue == 0) {
return false;
} else {
throw new IllegalArgumentException("Unexpected type with value: " + value);
}
}
return parseBigInt(value);
}
/**
* Boolector puts out Strings containing 1,0 or x that have to be parsed. If you want different
* values for x, change it in the constant! (BOOLECTOR_VARIABLE_ARBITRARI_REPLACEMENT)
*
* @param assignment String with the assignment of Boolector var.
* @return BigInteger in decimal.
*/
private BigInteger parseBigInt(String assignment) {
try {
BigInteger bigInt = new BigInteger(assignment, 2);
return bigInt;
} catch (NumberFormatException e) {
char[] charArray = assignment.toCharArray();
for (int i = 0; i < charArray.length; i++) {
if (charArray[i] == 'x') {
charArray[i] = ARBITRARY_VALUE;
} else if (charArray[i] != '0' && charArray[i] != '1') {
throw new IllegalArgumentException(
"Boolector gave back an assignment that is not parseable.");
}
}
assignment = String.valueOf(charArray);
}
return new BigInteger(assignment, 2);
}
/**
* Transforms String bitvec into Long.
*
* @param bitVec return value of Boolector
* @return gives back the long version of the bitvector
*/
private Long parseBitvector(String bitVec) {
try {
BigInteger bigInt = new BigInteger(bitVec, 2);
return bigInt.longValue();
} catch (NumberFormatException e) {
char[] charArray = bitVec.toCharArray();
for (int i = 0; i < charArray.length; i++) {
if (charArray[i] == 'x') {
charArray[i] = '1';
} else if (charArray[i] != '0' && charArray[i] != '1') {
throw new IllegalArgumentException(
"Boolector gave back an assignment that is not parseable.");
}
}
bitVec = String.valueOf(charArray);
}
BigInteger bigInt = new BigInteger(bitVec, 2);
return bigInt.longValue();
}
String getName(long pKey) {
return BtorJNI.boolector_get_symbol(getEnv(), pKey);
}
@Override
protected Long getBooleanVarDeclarationImpl(Long pTFormulaInfo) {
// declaration of constant or fun
if (BtorJNI.boolector_is_const(getEnv(), pTFormulaInfo)) {
return parseBitvector(BtorJNI.boolector_get_bits(getEnv(), pTFormulaInfo));
} else if (BtorJNI.boolector_is_var(getEnv(), pTFormulaInfo)) {
return parseBitvector(BtorJNI.boolector_bv_assignment(getEnv(), pTFormulaInfo));
} else {
throw new IllegalArgumentException(
"Debug only! getBooleanVarDeclarationImpl in BtorFormulaCreator");
}
}
// Returns the variables cache with keys variable name and type
protected Table<String, Long, Long> getCache() {
return formulaCache;
}
// True if the entered String has an existing variable in the cache.
protected boolean formulaCacheContains(String variable) {
// There is always only 1 type permitted per variable
return formulaCache.containsRow(variable);
}
// Optional that contains the variable to the entered String if there is one.
protected Optional<Long> getFormulaFromCache(String variable) {
Iterator<java.util.Map.Entry<Long, Long>> entrySetIter =
formulaCache.row(variable).entrySet().iterator();
if (entrySetIter.hasNext()) {
// If there is a non empty row for an entry, there is only one entry
return Optional.of(entrySetIter.next().getValue());
}
return Optional.empty();
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TI extends Formula, TE extends Formula> FormulaType<TE> getArrayFormulaElementType(
ArrayFormula<TI, TE> pArray) {
return ((BoolectorArrayFormula<TI, TE>) pArray).getElementType();
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TI extends Formula, TE extends Formula> FormulaType<TI> getArrayFormulaIndexType(
ArrayFormula<TI, TE> pArray) {
return ((BoolectorArrayFormula<TI, TE>) pArray).getIndexType();
}
}
| 16,882 | 38.818396 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorFormulaManager.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.boolector;
import java.io.IOException;
import org.sosy_lab.common.Appender;
import org.sosy_lab.common.Appenders;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.basicimpl.AbstractFormulaManager;
final class BoolectorFormulaManager extends AbstractFormulaManager<Long, Long, Long, Long> {
BoolectorFormulaManager(
BoolectorFormulaCreator pFormulaCreator,
BoolectorUFManager pFunctionManager,
BoolectorBooleanFormulaManager pBooleanManager,
BoolectorBitvectorFormulaManager pBitvectorManager,
BoolectorQuantifiedFormulaManager pQuantifierManager,
BoolectorArrayFormulaManager pArrayManager) {
super(
pFormulaCreator,
pFunctionManager,
pBooleanManager,
null,
null,
pBitvectorManager,
null,
pQuantifierManager,
pArrayManager,
null,
null,
null);
}
@Override
public BooleanFormula parse(String pS) throws IllegalArgumentException {
throw new UnsupportedOperationException("Boolector can not parse single formulas.");
}
@Override
public Appender dumpFormula(Long pT) {
return new Appenders.AbstractAppender() {
@Override
public void appendTo(Appendable out) throws IOException {
// TODO
// -- Possibility 1:
// Boolector can dump valid SMTLIB2 for a complete solver stack,
// thus we can create a new solver stack through cloning,
// assert the current node, and dump it.
// As the cloned stack also copies the existing stack from the original context,
// this method only works for an empty solver stack.
//
// The following code does not work:
// The cloned instance does only contain a TRUE assertion. ???
//
// long clone = BtorJNI.boolector_clone(getEnvironment());
// long matchingNode = BtorJNI.boolector_match_node(clone, pT);
// BtorJNI.boolector_assert(clone, matchingNode);
// String dump = BtorJNI.boolector_help_dump_smt2(clone);
// BtorJNI.boolector_delete(clone);
//
// // cleanup the string
// String suffix = "\n(check-sat)\n(exit)\n";
// Preconditions.checkState(dump.endsWith(suffix));
// dump = dump.substring(0, dump.length() - suffix.length());
// out.append(dump);
// -- End Possibility 1
// -- Possibility 2:
// Dump a single node from Boolector via boolector_help_dump_node_smt2.
// Therefore, we need to dump all used symbols and add SMTLIB2-related parts
// like "assert" and "declare-fun" on our own.
// This requires direct access to the children/sub-formulae of a formula,
// which is not available in Boolector.
// This is the same reason why visitor is not fully implemented.
// -- End Possibility 2
// -- Possibility 3: minimal working solution with invalid SMTLIB2.
// This method only dumps the current node, i.e.,
// in case of "symbol" we only get the declaration, in case of "formula with
// operator" we get a nice String, but without any symbol declaration.
// The name of a symbol might be prefixed with "BTOR_%d@".format(solver.level).
// As Boolector supports only one stack at the moment,
// the name of a symbol in the dump depends on the overall context.
String dump = BtorJNI.boolector_help_dump_node_smt2(getEnvironment(), pT);
// strip removes the newline at the end of the string
out.append(dump.strip());
// -- End Possibility 3
}
};
}
static long getBtorTerm(Formula pT) {
return ((BoolectorFormula) pT).getTerm();
}
}
| 4,053 | 36.537037 | 92 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorModel.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.boolector;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.sosy_lab.java_smt.basicimpl.AbstractModel;
class BoolectorModel extends AbstractModel<Long, Long, Long> {
private static final ImmutableSet<String> SMT_KEYWORDS =
ImmutableSet.of(
"let",
"forall",
"exists",
"match",
"Bool",
"continued-execution",
"error",
"immediate-exit",
"incomplete",
"logic",
"memout",
"sat",
"success",
"theory",
"unknown",
"unsupported",
"unsat",
"_",
"as",
"BINARY",
"DECIMAL",
"HEXADECIMAL",
"NUMERAL",
"par",
"STRING",
"assert",
"check-sat",
"check-sat-assuming",
"declare-const",
"declare-datatype",
"declare-datatypes",
"declare-fun",
"declare-sort",
"define-fun",
"define-fun-rec",
"define-sort",
"echo",
"exit",
"get-assertions",
"get-assignment",
"get-info",
"get-model",
"get-option",
"get-proof",
"get-unsat-assumptions",
"get-unsat-core",
"get-value",
"pop",
"push",
"reset",
"reset-assertions",
"set-info",
"set-logic",
"set-option");
private final long btor;
private final BoolectorAbstractProver<?> prover;
private final BoolectorFormulaCreator bfCreator;
private final ImmutableList<Long> assertedTerms;
BoolectorModel(
long btor,
BoolectorFormulaCreator creator,
BoolectorAbstractProver<?> pProver,
Collection<Long> assertedTerms) {
super(pProver, creator);
this.bfCreator = creator;
this.btor = btor;
this.prover = pProver;
this.assertedTerms = ImmutableList.copyOf(assertedTerms);
}
@Override
public void close() {
if (!isClosed()) {
// TODO Technically Boolector has no model, but you could release all bindings.
}
super.close();
}
/* (non-Javadoc)
* Escape characters are used if the string contains i.e. spaces or ( ).
* If one wants to use |, one needs an escape char, either | or \
* Get String representation for each asserted term
* Search each string for variables/ufs/arrays and gather them by using the vars cache
* Split of () at the beginning and end, get substrings by spaces if no | is present, get
* substrings encasing | | without escape chars else then by spacing
* (\|.+?\|(?<!\\\|))|
* It might be that Boolector uses "BTOR_1@varname" or BTORanyNumber@ (their own BTOR format)
* for some reason as an escape for vars! We set the proper option that it should always
* return smt2, but ok.
* There is some number before the @, the varname is after the @
* There is no further escape in this case, so a var named "@a" will be returned as
* "BTOR_2@@a"
* It might occur that it is double escaped, with smt2 escape and btor escape, example:
* |BTOR_22@bla|
* Further, it might be that Boolector returns the variable name with its own escape added, so
* we have to strip this if it occurs
*/
@Override
public ImmutableList<ValueAssignment> asList() {
Preconditions.checkState(!isClosed());
Preconditions.checkState(!prover.isClosed(), "cannot use model after prover is closed");
// Use String instead of the node (long) as we need the name again later!
ImmutableSet.Builder<String> variablesBuilder = ImmutableSet.builder();
for (long term : assertedTerms) {
String termString = BtorJNI.boolector_help_dump_node_smt2(btor, term);
List<String> escapedList = new ArrayList<>();
// Matches all escaped names
Pattern pattern = Pattern.compile("(\\|.+?\\|(?<!\\\\\\|))");
Matcher matcher = pattern.matcher(termString);
while (matcher.find()) {
escapedList.add(matcher.group());
}
// Now remove all escaped strings from the term string as it allows
// special characters/keywords
String inputReplaced = termString;
for (String escaped : escapedList) {
inputReplaced = inputReplaced.replace(escaped, "");
}
// Delete brackets, but keep the spaces, then split on spaces into substrings
inputReplaced = inputReplaced.replace("(", " ").replace(")", " ");
Iterable<String> maybeVars = Splitter.onPattern("\\s+").split(inputReplaced);
// maybeVars may include a lot of unnecessary Strings, including SMT keywords or empty
// strings. However, removing them would just increase runtime with no benefit as we check
// them against the variables cache.
// TODO: decide if its benefitial to code cleanness and structure to handle the strings
// proper, or else remove the SMT_KEYWORDS
// Strings in maybeVars may not have SMTLIB2 keywords
for (String var : maybeVars) {
// Strip Boolector escape sequence (BTOR_number@; example: BTOR_1@)
// It seems like that if the escape seq is used as a name, there will be an escape seq
// before it. Always only removing the first should be fine
String varReplaced = var.replaceFirst("^(BTOR_\\d+@)", "");
if (!SMT_KEYWORDS.contains(varReplaced) && bfCreator.formulaCacheContains(varReplaced)) {
variablesBuilder.add(varReplaced);
}
}
// escaped Strings may have SMTLIB2 keywords in them
for (String var : escapedList) {
// Get rid of the sourrounding | and strip Boolector escape sequence (BTOR_number@; example:
// BTOR_1@) if present
String varSubs = var.substring(1, var.length() - 1).replaceFirst("^(BTOR_\\d+@)", "");
if (bfCreator.formulaCacheContains(varSubs)) {
variablesBuilder.add(varSubs);
}
}
}
return toList1(variablesBuilder.build());
}
private ImmutableList<ValueAssignment> toList1(Set<String> variables) {
Preconditions.checkState(!isClosed());
Preconditions.checkState(!prover.isClosed(), "cannot use model after prover is closed");
ImmutableList.Builder<ValueAssignment> assignmentBuilder = ImmutableList.builder();
for (String name : variables) {
// We get the formula here as we need the name.
// Reason: Boolector returns names of variables with its own escape sequence sometimes. If you
// however name your variable like the escape sequence, we can't discern anymore if its a real
// name or an escape seq.
long entry = bfCreator.getFormulaFromCache(name).orElseThrow();
if (BtorJNI.boolector_is_array(btor, entry)) {
assignmentBuilder.add(getArrayAssignment(entry, name));
} else if (BtorJNI.boolector_is_const(btor, entry)) {
// Don't remove this! Some consts are Ufs in the eyes of Boolector, however,
// we want them as consts!
assignmentBuilder.add(getConstAssignment(entry, name));
} else if (BtorJNI.boolector_is_uf(btor, entry)) {
assignmentBuilder.addAll(getUFAssignments(entry, name));
} else {
// This is the Bv case
assignmentBuilder.add(getConstAssignment(entry, name));
}
}
return assignmentBuilder.build();
}
private ValueAssignment getConstAssignment(long key, String name) {
List<Object> argumentInterpretation = new ArrayList<>();
Object value = creator.convertValue(key, evalImpl(key));
Long valueNode = BtorJNI.boolector_get_value(btor, key);
// Boolector might return the internal name of the variable with a leading BTOR_number@ which we
// need to strip!
return new ValueAssignment(
creator.encapsulateWithTypeOf(key),
creator.encapsulateWithTypeOf(valueNode),
creator.encapsulateBoolean(BtorJNI.boolector_eq(btor, key, valueNode)),
name,
value,
argumentInterpretation);
}
private ImmutableList<ValueAssignment> getUFAssignments(long key, String name) {
ImmutableList.Builder<ValueAssignment> assignments = ImmutableList.builder();
// Don't use the creator with convertValue() as while it returns the correct values, the order
// of values may differ when calling boolector_uf_assignment_helper again to get the arguments!
// The "value" from boolector_get_value() is just
// a plain copy of the entered node with static results!
Long fun = BtorJNI.boolector_get_value(btor, key);
String[][] ufAssignments = BtorJNI.boolector_uf_assignment_helper(btor, key);
for (int i = 0; i < ufAssignments[0].length; i++) {
ImmutableList.Builder<Object> argBuilder = ImmutableList.builder();
String arguments = ufAssignments[0][i];
Object value = bfCreator.transformStringToBigInt(ufAssignments[1][i]);
for (String arg : Splitter.onPattern("\\s+").splitToList(arguments)) {
argBuilder.add(bfCreator.transformStringToBigInt(arg));
}
Long equality = BtorJNI.boolector_eq(btor, key, fun);
// Boolector might return the internal name of the variable with a leading BTOR_number@ which
// we need to strip!
assignments.add(
new ValueAssignment(
creator.encapsulateWithTypeOf(key),
creator.encapsulateWithTypeOf(fun),
creator.encapsulateBoolean(equality),
name,
value,
argBuilder.build()));
}
return assignments.build();
}
private ValueAssignment getArrayAssignment(long key, String name) {
// Don't use the creator with convertValue() as while it returns the correct values, the order
// of values may differ when calling boolector_array_assignment_helper again to get the
// arguments!
List<Object> argumentInterpretation = new ArrayList<>();
for (String stringArrayEntry : BtorJNI.boolector_array_assignment_helper(btor, key)[0]) {
argumentInterpretation.add(bfCreator.transformStringToBigInt(stringArrayEntry));
}
Object value = creator.convertValue(key, evalImpl(key));
Long valueNode = BtorJNI.boolector_get_value(btor, key);
// Boolector might return the internal name of the variable with a leading BTOR_number@ which we
// need to strip!
return new ValueAssignment(
creator.encapsulateWithTypeOf(key),
creator.encapsulateWithTypeOf(valueNode),
creator.encapsulateBoolean(BtorJNI.boolector_eq(btor, key, valueNode)),
name,
value,
argumentInterpretation);
}
@Override
protected Long evalImpl(Long pFormula) {
Preconditions.checkState(!isClosed());
return pFormula;
}
}
| 11,264 | 38.526316 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorNativeApiTest.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.boolector;
import static com.google.common.truth.Truth.assertThat;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import java.util.Arrays;
import java.util.Locale;
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.ShutdownNotifier;
import org.sosy_lab.common.configuration.Configuration;
import org.sosy_lab.common.configuration.ConfigurationBuilder;
import org.sosy_lab.common.configuration.InvalidConfigurationException;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.BooleanFormulaManager;
import org.sosy_lab.java_smt.api.FormulaManager;
import org.sosy_lab.java_smt.api.ProverEnvironment;
import org.sosy_lab.java_smt.api.SolverException;
import org.sosy_lab.java_smt.solvers.boolector.BoolectorSolverContext.SatSolver;
public class BoolectorNativeApiTest {
private long btor;
@BeforeClass
public static void load() {
try {
NativeLibraries.loadLibrary("boolector");
} catch (UnsatisfiedLinkError e) {
throw new AssumptionViolatedException("Boolector is not available", e);
}
}
@Before
public void createEnvironment() {
btor = BtorJNI.boolector_new();
}
@After
public void freeEnvironment() {
BtorJNI.boolector_delete(btor);
}
// some options have a different name in the API that their internal representation.
// TODO why?
// Because for some reason the return value of the get_opt method is not the correct option name
// (check btortypes.h for correct options)
private static final ImmutableMap<String, String> ALLOWED_DIFFS =
ImmutableMap.<String, String>builder()
.put("BTOR_OPT_ACKERMANNIZE", "BTOR_OPT_ACKERMANN")
.put("BTOR_OPT_QUANT_DUAL", "BTOR_OPT_QUANT_DUAL_SOLVER")
.put("BTOR_OPT_QUANT_SYNTHLIMIT", "BTOR_OPT_QUANT_SYNTH_LIMIT")
.put("BTOR_OPT_QUANT_SYNTHQI", "BTOR_OPT_QUANT_SYNTH_QI")
.put("BTOR_OPT_QUANT_MS", "BTOR_OPT_QUANT_MINISCOPE")
.put("BTOR_OPT_QUANT_SYNTHCOMPLETE", "BTOR_OPT_QUANT_SYNTH_ITE_COMPLETE")
.put("BTOR_OPT_BETA_REDUCE", "BTOR_OPT_BETA_REDUCE")
.put("BTOR_OPT_DUMP_DIMACS", "BTOR_OPT_PRINT_DIMACS")
.put("BTOR_OPT_SIMP_NORM_ADDS", "BTOR_OPT_SIMP_NORMAMLIZE_ADDERS")
.buildOrThrow();
@Test
public void optionNameTest() {
// check whether our enum is identical to Boolector's internal enum
for (BtorOption option : BtorOption.values()) {
String optName = BtorJNI.boolector_get_opt_lng(btor, option.getValue());
String converted =
"BTOR_OPT_"
+ optName.replace("-", "_").replace(":", "_").toUpperCase(Locale.getDefault());
assertThat(option.name()).isEqualTo(ALLOWED_DIFFS.getOrDefault(converted, converted));
}
}
@Test
public void satSolverTest() {
// check whether all sat solvers are available
for (SatSolver satSolver : SatSolver.values()) {
long btor1 = BtorJNI.boolector_new();
BtorJNI.boolector_set_sat_solver(btor1, satSolver.name().toLowerCase(Locale.getDefault()));
long newVar = BtorJNI.boolector_var(btor1, BtorJNI.boolector_bool_sort(btor1), "x");
BtorJNI.boolector_assert(btor1, newVar);
int result = BtorJNI.boolector_sat(btor1);
assertThat(result).isEqualTo(BtorJNI.BTOR_RESULT_SAT_get());
BtorJNI.boolector_delete(btor1);
}
}
/**
* For each available solver, we build a context and solver a small formula.
*
* <p>This should be sufficient to test whether the sat-solver can be loaded.
*/
@Test
public void satSolverBackendTest()
throws InvalidConfigurationException, InterruptedException, SolverException {
for (SatSolver satsolver : BoolectorSolverContext.SatSolver.values()) {
ConfigurationBuilder config =
Configuration.builder().setOption("solver.boolector.satSolver", satsolver.name());
try (BoolectorSolverContext context =
BoolectorSolverContext.create(
config.build(),
ShutdownNotifier.createDummy(),
null,
1,
NativeLibraries::loadLibrary)) {
BooleanFormulaManager bfmgr = context.getFormulaManager().getBooleanFormulaManager();
BooleanFormula fa = bfmgr.makeVariable("a");
BooleanFormula fb = bfmgr.makeVariable("b");
BooleanFormula fc = bfmgr.makeVariable("c");
BooleanFormula f1 = bfmgr.or(fa, fb, fc);
BooleanFormula f2 = bfmgr.and(fa, fb, fc);
try (ProverEnvironment prover = context.newProverEnvironment()) {
prover.addConstraint(bfmgr.equivalence(f1, f2));
assertThat(prover.isUnsat()).isFalse();
}
}
}
}
@Test
public void dumpVariableTest() throws InvalidConfigurationException {
ConfigurationBuilder config = Configuration.builder();
try (BoolectorSolverContext context =
BoolectorSolverContext.create(
config.build(),
ShutdownNotifier.createDummy(),
null,
1,
NativeLibraries::loadLibrary)) {
FormulaManager mgr = context.getFormulaManager();
BooleanFormulaManager bfmgr = mgr.getBooleanFormulaManager();
for (String name : ImmutableList.of("a", "a", "b", "abc", "ABC")) {
BooleanFormula f = bfmgr.makeVariable(name);
String s = mgr.dumpFormula(f).toString();
assertThat(s).contains(String.format("(declare-fun %s () (_ BitVec 1))", name));
// assertThat(s).contains(String.format("(assert %s)", name)); // assertion not available
}
}
}
@Test
public void dumpVariableWithAssertionsOnStackTest()
throws InvalidConfigurationException, InterruptedException {
ConfigurationBuilder config = Configuration.builder();
try (BoolectorSolverContext context =
BoolectorSolverContext.create(
config.build(),
ShutdownNotifier.createDummy(),
null,
1,
NativeLibraries::loadLibrary)) {
FormulaManager mgr = context.getFormulaManager();
BooleanFormulaManager bfmgr = mgr.getBooleanFormulaManager();
try (ProverEnvironment prover = context.newProverEnvironment()) {
prover.push(bfmgr.makeVariable("x"));
for (String name : ImmutableList.of("a", "a", "b", "abc", "ABC")) {
BooleanFormula f = bfmgr.makeVariable(name);
String s = mgr.dumpFormula(f).toString();
// TODO why is there a prefix "BTOR_2@"?
// Possible reason: we are on the second level of the solver stack.
// - first level comes from the constructor of ReusableStackTheoremProver.
// - second level comes from the PUSH above.
// We do actually not want to have such names in the dump.
assertThat(s).contains(String.format("(declare-fun BTOR_2@%s () (_ BitVec 1))", name));
// assertThat(s).contains(String.format("(assert "));
}
}
}
}
@Test
public void repeatedDumpFormulaTest() throws InvalidConfigurationException {
ConfigurationBuilder config = Configuration.builder();
try (BoolectorSolverContext context =
BoolectorSolverContext.create(
config.build(),
ShutdownNotifier.createDummy(),
null,
1,
NativeLibraries::loadLibrary)) {
FormulaManager mgr = context.getFormulaManager();
BooleanFormulaManager bfmgr = mgr.getBooleanFormulaManager();
BooleanFormula fa = bfmgr.makeVariable("a");
BooleanFormula fb = bfmgr.makeVariable("b");
BooleanFormula fc = bfmgr.makeVariable("c");
BooleanFormula f1 = bfmgr.or(fa, bfmgr.and(fb, fc));
BooleanFormula f2 = bfmgr.or(fa, bfmgr.and(fb, fc));
String s1 = mgr.dumpFormula(f1).toString();
// repeat several times to increase probability for non-deterministic behavior
for (int i = 0; i < 10; i++) {
assertThat(s1).isEqualTo(mgr.dumpFormula(f2).toString());
}
}
}
/*
* Test Boolector model with bvs
* x > 0 && y > 0 && x <= 100 && y <= 100 && x * y < 100 with overflow protection
*/
@Test
public void bvModelTest() {
// Activate model gen
BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_MODEL_GEN.getValue(), 1);
// Create the formula and assert
long bvSort = BtorJNI.boolector_bitvec_sort(btor, 8);
long x = BtorJNI.boolector_var(btor, bvSort, "x");
long y = BtorJNI.boolector_var(btor, bvSort, "y");
long zero = BtorJNI.boolector_zero(btor, bvSort);
long hundred = BtorJNI.boolector_int(btor, 100, bvSort);
long zeroLTX = BtorJNI.boolector_ult(btor, zero, x);
long xLTEHundred = BtorJNI.boolector_ulte(btor, x, hundred);
long zeroLTY = BtorJNI.boolector_ult(btor, zero, y);
long yLTEHundred = BtorJNI.boolector_ulte(btor, y, hundred);
long mulXY = BtorJNI.boolector_mul(btor, y, x);
long mulXYLTHundred = BtorJNI.boolector_ult(btor, mulXY, hundred);
long formulaBigger0 = BtorJNI.boolector_and(btor, zeroLTX, zeroLTY);
long formulaLTE100 = BtorJNI.boolector_and(btor, xLTEHundred, yLTEHundred);
long formula0And100 = BtorJNI.boolector_and(btor, formulaBigger0, formulaLTE100);
long formula = BtorJNI.boolector_and(btor, mulXYLTHundred, formula0And100);
BtorJNI.boolector_assert(btor, formula);
// Overflow protection
long overflow = BtorJNI.boolector_not(btor, BtorJNI.boolector_umulo(btor, x, y));
BtorJNI.boolector_assert(btor, overflow);
// Check SAT
assertThat(BtorJNI.boolector_sat(btor)).isEqualTo(BtorJNI.BTOR_RESULT_SAT_get());
// use get_value() to get values from nodes
long xValue = BtorJNI.boolector_get_value(btor, x);
long yValue = BtorJNI.boolector_get_value(btor, y);
// check the type
assertThat(BtorJNI.boolector_get_sort(btor, xValue))
.isEqualTo(BtorJNI.boolector_get_sort(btor, x));
assertThat(BtorJNI.boolector_get_sort(btor, yValue))
.isEqualTo(BtorJNI.boolector_get_sort(btor, y));
String xValueString = BtorJNI.boolector_bv_assignment(btor, xValue);
String yValueString = BtorJNI.boolector_bv_assignment(btor, yValue);
// Check that the values are the same
assertThat(xValueString).isEqualTo(BtorJNI.boolector_bv_assignment(btor, x));
assertThat(yValueString).isEqualTo(BtorJNI.boolector_bv_assignment(btor, y));
assertThat(Integer.parseInt(xValueString, 2) * Integer.parseInt(yValueString, 2))
.isLessThan(100);
assertThat(Integer.parseInt(xValueString, 2)).isAtMost(100);
assertThat(Integer.parseInt(yValueString, 2)).isAtMost(100);
assertThat(Integer.parseInt(xValueString, 2)).isAtLeast(1);
assertThat(Integer.parseInt(yValueString, 2)).isAtLeast(1);
}
/*
* Test array model for Boolector.
* (= (select arr 5) x)
* (= x 123)
* (= (select arr 2) y)
* (= y 0)
*/
@Test
public void bvArrayModelTest() {
// Activate model gen
BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_MODEL_GEN.getValue(), 1);
// Create the formula and assert
long bvSort = BtorJNI.boolector_bitvec_sort(btor, 8);
long arraySort = BtorJNI.boolector_array_sort(btor, bvSort, bvSort);
long array = BtorJNI.boolector_array(btor, arraySort, "array");
long x = BtorJNI.boolector_var(btor, bvSort, "x");
long y = BtorJNI.boolector_var(btor, bvSort, "y");
long zero = BtorJNI.boolector_zero(btor, bvSort);
long const123 = BtorJNI.boolector_int(btor, 123, bvSort);
long const2 = BtorJNI.boolector_int(btor, 2, bvSort);
long const5 = BtorJNI.boolector_int(btor, 5, bvSort);
// (= (select arr 5) x)
long xEqArrayAt5 = BtorJNI.boolector_eq(btor, x, BtorJNI.boolector_read(btor, array, const5));
// (= x 123)
long xEq123 = BtorJNI.boolector_eq(btor, x, const123);
// (= y 0)
long yEq0 = BtorJNI.boolector_eq(btor, y, zero);
// (= (select arr 2) y)
long yEqArrayAt2 = BtorJNI.boolector_eq(btor, y, BtorJNI.boolector_read(btor, array, const2));
long arrayAt5Formulas = BtorJNI.boolector_and(btor, xEqArrayAt5, xEq123);
long arrayAt2Formulas = BtorJNI.boolector_and(btor, yEq0, yEqArrayAt2);
long formula = BtorJNI.boolector_and(btor, arrayAt5Formulas, arrayAt2Formulas);
BtorJNI.boolector_assert(btor, formula);
// Check SAT
assertThat(BtorJNI.boolector_sat(btor)).isEqualTo(BtorJNI.BTOR_RESULT_SAT_get());
// use get_value() to get values from nodes
long xValue = BtorJNI.boolector_get_value(btor, x);
long yValue = BtorJNI.boolector_get_value(btor, y);
long arrayValue = BtorJNI.boolector_get_value(btor, array);
// check the type
assertThat(BtorJNI.boolector_get_sort(btor, xValue))
.isEqualTo(BtorJNI.boolector_get_sort(btor, x));
assertThat(BtorJNI.boolector_get_sort(btor, yValue))
.isEqualTo(BtorJNI.boolector_get_sort(btor, y));
assertThat(BtorJNI.boolector_get_sort(btor, arrayValue))
.isEqualTo(BtorJNI.boolector_get_sort(btor, array));
// Check that the values are the same
assertThat(BtorJNI.boolector_bv_assignment(btor, xValue))
.isEqualTo(BtorJNI.boolector_bv_assignment(btor, x));
assertThat(BtorJNI.boolector_bv_assignment(btor, yValue))
.isEqualTo(BtorJNI.boolector_bv_assignment(btor, y));
// The assignment_helper generates the assignments in a array of arrays!
String[][] arrayValueHelperArray = BtorJNI.boolector_array_assignment_helper(btor, arrayValue);
String[] arrayValueIndices = arrayValueHelperArray[0];
Arrays.sort(arrayValueIndices);
String[] arrayValueValues = arrayValueHelperArray[1];
Arrays.sort(arrayValueValues);
String[][] arrayHelperArray = BtorJNI.boolector_array_assignment_helper(btor, array);
String[] arrayIndices = arrayHelperArray[0];
Arrays.sort(arrayIndices);
String[] arrayValues = arrayHelperArray[1];
Arrays.sort(arrayValues);
// TODO: Is it better to convert arrays into lists and check via containsExactlyElementsIn() or
// sort them and compare?
assertThat(arrayValueIndices).isEqualTo(arrayIndices);
assertThat(arrayValueValues).isEqualTo(arrayValues);
assertThat(arrayValueIndices).asList().containsExactly("00000010", "00000101");
assertThat(arrayValueValues).asList().containsExactly("00000000", "01111011");
}
/*
* Test uf model for Boolector.
* (= f(x) 5)
* (= x 123)
* (= g(2) y)
* (= y 0)
*/
@Test
public void ufModelTest1() {
// Activate model gen
BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_MODEL_GEN.getValue(), 1);
// Create the formula and assert
long bvSort = BtorJNI.boolector_bitvec_sort(btor, 8);
long funSort = BtorJNI.boolector_fun_sort(btor, new long[] {bvSort}, 1, bvSort);
long uf1 = BtorJNI.boolector_uf(btor, funSort, "f");
long uf2 = BtorJNI.boolector_uf(btor, funSort, "g");
long x = BtorJNI.boolector_var(btor, bvSort, "x");
long y = BtorJNI.boolector_var(btor, bvSort, "y");
long zero = BtorJNI.boolector_zero(btor, bvSort);
long const123 = BtorJNI.boolector_int(btor, 123, bvSort);
long const2 = BtorJNI.boolector_int(btor, 2, bvSort);
long const5 = BtorJNI.boolector_int(btor, 5, bvSort);
long applyUf1EqX =
BtorJNI.boolector_eq(btor, BtorJNI.boolector_apply(btor, new long[] {x}, 1, uf1), const5);
long xEq123 = BtorJNI.boolector_eq(btor, x, const123);
long yEq0 = BtorJNI.boolector_eq(btor, y, zero);
long applyUf2EqY =
BtorJNI.boolector_eq(btor, BtorJNI.boolector_apply(btor, new long[] {const2}, 1, uf2), y);
long subformula1 = BtorJNI.boolector_and(btor, applyUf1EqX, xEq123);
long subformula2 = BtorJNI.boolector_and(btor, yEq0, applyUf2EqY);
long formula = BtorJNI.boolector_and(btor, subformula1, subformula2);
BtorJNI.boolector_assert(btor, formula);
// Check SAT
assertThat(BtorJNI.boolector_sat(btor)).isEqualTo(BtorJNI.BTOR_RESULT_SAT_get());
// use get_value() to get values from nodes
long xValue = BtorJNI.boolector_get_value(btor, x);
long yValue = BtorJNI.boolector_get_value(btor, y);
long uf1Value = BtorJNI.boolector_get_value(btor, uf1);
long uf2Value = BtorJNI.boolector_get_value(btor, uf2);
// check the type
assertThat(BtorJNI.boolector_get_sort(btor, uf1Value))
.isEqualTo(BtorJNI.boolector_get_sort(btor, uf1));
assertThat(BtorJNI.boolector_get_sort(btor, uf2Value))
.isEqualTo(BtorJNI.boolector_get_sort(btor, uf2));
String[][] uf1Assignments = BtorJNI.boolector_uf_assignment_helper(btor, uf1);
String[][] uf2Assignments = BtorJNI.boolector_uf_assignment_helper(btor, uf2);
// Check that the values are the same
assertThat(BtorJNI.boolector_bv_assignment(btor, xValue))
.isEqualTo(BtorJNI.boolector_bv_assignment(btor, x));
assertThat(BtorJNI.boolector_bv_assignment(btor, yValue))
.isEqualTo(BtorJNI.boolector_bv_assignment(btor, y));
// Argument of f (=123)
assertThat(uf1Assignments[0][0]).isEqualTo("01111011");
// Value of f (=5)
assertThat(uf1Assignments[1][0]).isEqualTo("00000101");
// Argument of g (=2)
assertThat(uf2Assignments[0][0]).isEqualTo("00000010");
// Value of g (=0)
assertThat(uf2Assignments[1][0]).isEqualTo("00000000");
}
/*
* Test that the value node stays valid if the values from which it is derived change.
*
* x > 0 && y > 0 && x <= 100 && y <= 100 && x * y < 100 with overflow protection
* Get value nodes. Check value for x and y and add inequalities such that they can't
* be the same value as before. Check SAT and get new value nodes and check all
* value nodes.
*/
@Test
public void bvModelConsistencyTest() {
// Activate model gen
BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_MODEL_GEN.getValue(), 1);
// Incremental mode to enable multiple SAT calls
BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_INCREMENTAL.getValue(), 1);
// Create the formula and assert
long bvSort = BtorJNI.boolector_bitvec_sort(btor, 8);
long x = BtorJNI.boolector_var(btor, bvSort, "x");
long y = BtorJNI.boolector_var(btor, bvSort, "y");
long zero = BtorJNI.boolector_zero(btor, bvSort);
long hundred = BtorJNI.boolector_int(btor, 100, bvSort);
long zeroLTX = BtorJNI.boolector_ult(btor, zero, x);
long xLTEHundred = BtorJNI.boolector_ulte(btor, x, hundred);
long zeroLTY = BtorJNI.boolector_ult(btor, zero, y);
long yLTEHundred = BtorJNI.boolector_ulte(btor, y, hundred);
long mulXY = BtorJNI.boolector_mul(btor, y, x);
long mulXYLTHundred = BtorJNI.boolector_ult(btor, mulXY, hundred);
long formulaBigger0 = BtorJNI.boolector_and(btor, zeroLTX, zeroLTY);
long formulaLTE100 = BtorJNI.boolector_and(btor, xLTEHundred, yLTEHundred);
long formula0And100 = BtorJNI.boolector_and(btor, formulaBigger0, formulaLTE100);
long formula = BtorJNI.boolector_and(btor, mulXYLTHundred, formula0And100);
BtorJNI.boolector_assert(btor, formula);
// Overflow protection
long overflow = BtorJNI.boolector_not(btor, BtorJNI.boolector_umulo(btor, x, y));
BtorJNI.boolector_assert(btor, overflow);
// Check SAT
assertThat(BtorJNI.boolector_sat(btor)).isEqualTo(BtorJNI.BTOR_RESULT_SAT_get());
// remember values and nodes
long xValueInitial = BtorJNI.boolector_get_value(btor, x);
long yValueInitial = BtorJNI.boolector_get_value(btor, y);
String xStringInitial = BtorJNI.boolector_bv_assignment(btor, xValueInitial);
String yStringInitial = BtorJNI.boolector_bv_assignment(btor, yValueInitial);
// Add x != old value and the same for y
long xNEQx =
BtorJNI.boolector_not(
btor,
BtorJNI.boolector_eq(
btor, BtorJNI.boolector_int(btor, Integer.parseInt(xStringInitial, 2), bvSort), x));
long yNEQy =
BtorJNI.boolector_not(
btor,
BtorJNI.boolector_eq(
btor, BtorJNI.boolector_int(btor, Integer.parseInt(yStringInitial, 2), bvSort), y));
long formulaVarsNE = BtorJNI.boolector_and(btor, xNEQx, yNEQy);
BtorJNI.boolector_assert(btor, formulaVarsNE);
// Check SAT again
assertThat(BtorJNI.boolector_sat(btor)).isEqualTo(BtorJNI.BTOR_RESULT_SAT_get());
long xValueNew = BtorJNI.boolector_get_value(btor, x);
long yValueNew = BtorJNI.boolector_get_value(btor, y);
String xStringNew = BtorJNI.boolector_bv_assignment(btor, xValueNew);
String yStringNew = BtorJNI.boolector_bv_assignment(btor, yValueNew);
// Check that the values are not the same
assertThat(xStringInitial).isNotEqualTo(xStringNew);
assertThat(yStringInitial).isNotEqualTo(yStringNew);
}
}
| 21,118 | 42.01222 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorQuantifiedFormulaManager.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.boolector;
import static com.google.common.base.Preconditions.checkArgument;
import com.google.common.collect.ImmutableList;
import com.google.common.primitives.Longs;
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 BoolectorQuantifiedFormulaManager
extends AbstractQuantifiedFormulaManager<Long, Long, Long, Long> {
private final long btor;
BoolectorQuantifiedFormulaManager(FormulaCreator<Long, Long, Long, Long> pCreator) {
super(pCreator);
btor = getFormulaCreator().getEnv();
}
@Override
protected Long eliminateQuantifiers(Long pExtractInfo)
throws SolverException, InterruptedException {
throw new UnsupportedOperationException("Boolector can not eliminate quantifier.");
}
/**
* Note: Boolector only supports bitvector quantifier! The vars used MUST be boolector_param (not
* boolector_var)! Therefore, we have to change every var into param with the visitor!
* Additionally, no param may be used twice (Boolector will end if you do!).
*/
// TODO with the comment above, the user has no way to call boolector_param.
// This implementation seems to be broken and not usable.
@Override
public Long mkQuantifier(Quantifier pQ, List<Long> pVars, Long pBody) {
checkArgument(!pVars.isEmpty(), "List of quantified variables can not be empty");
for (long param : pVars) {
checkArgument(
BtorJNI.boolector_is_param(btor, param),
"pVariables need to be parameter nodes in boolector.");
}
final long newQuantifier;
final long[] varsArray = Longs.toArray(pVars);
if (pQ == Quantifier.FORALL) {
newQuantifier = BtorJNI.boolector_forall(btor, varsArray, varsArray.length, pBody);
} else {
newQuantifier = BtorJNI.boolector_exists(btor, varsArray, varsArray.length, pBody);
}
return newQuantifier;
}
static class QuantifiedFormula {
private final boolean isForall; // false for EXISTS, true for FORALL
private final long body;
private final ImmutableList<Long> boundVariables;
QuantifiedFormula(boolean pIsForall, long pBody, List<Long> pVars) {
isForall = pIsForall;
body = pBody;
boundVariables = ImmutableList.copyOf(pVars);
}
public boolean isForall() {
return isForall;
}
public long getBody() {
return body;
}
public ImmutableList<Long> getBoundVariables() {
return boundVariables;
}
}
}
| 2,865 | 32.717647 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorSolverContext.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.boolector;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.base.Splitter.MapSplitter;
import com.google.common.collect.ImmutableMap;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.common.configuration.Configuration;
import org.sosy_lab.common.configuration.InvalidConfigurationException;
import org.sosy_lab.common.configuration.Option;
import org.sosy_lab.common.configuration.Options;
import org.sosy_lab.common.io.PathCounterTemplate;
import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
import org.sosy_lab.java_smt.api.OptimizationProverEnvironment;
import org.sosy_lab.java_smt.api.ProverEnvironment;
import org.sosy_lab.java_smt.basicimpl.AbstractSolverContext;
public final class BoolectorSolverContext extends AbstractSolverContext {
enum SatSolver {
LINGELING,
PICOSAT,
MINISAT,
CMS,
CADICAL
}
@Options(prefix = "solver.boolector")
private static class BoolectorSettings {
@Option(secure = true, description = "The SAT solver used by Boolector.")
private SatSolver satSolver = SatSolver.CADICAL;
@Option(
secure = true,
description =
"Further options for Boolector in addition to the default options. "
+ "Format: \"Optionname=value\" with ’,’ to seperate options. "
+ "Optionname and value can be found in BtorOption or Boolector C Api."
+ "Example: \"BTOR_OPT_MODEL_GEN=2,BTOR_OPT_INCREMENTAL=1\".")
private String furtherOptions = "";
BoolectorSettings(Configuration config) throws InvalidConfigurationException {
config.inject(this);
}
}
private final BoolectorFormulaManager manager;
private final BoolectorFormulaCreator creator;
private final ShutdownNotifier shutdownNotifier;
private boolean closed = false;
private final AtomicBoolean isAnyStackAlive = new AtomicBoolean(false);
BoolectorSolverContext(
BoolectorFormulaManager pManager,
BoolectorFormulaCreator pCreator,
ShutdownNotifier pShutdownNotifier) {
super(pManager);
manager = pManager;
creator = pCreator;
shutdownNotifier = pShutdownNotifier;
}
public static BoolectorSolverContext create(
Configuration config,
ShutdownNotifier pShutdownNotifier,
@Nullable PathCounterTemplate solverLogfile,
long randomSeed,
Consumer<String> pLoader)
throws InvalidConfigurationException {
pLoader.accept("boolector");
final long btor = BtorJNI.boolector_new();
setOptions(config, solverLogfile, randomSeed, btor);
BoolectorFormulaCreator creator = new BoolectorFormulaCreator(btor);
BoolectorUFManager functionTheory = new BoolectorUFManager(creator);
BoolectorBooleanFormulaManager booleanTheory = new BoolectorBooleanFormulaManager(creator);
BoolectorBitvectorFormulaManager bitvectorTheory =
new BoolectorBitvectorFormulaManager(creator, booleanTheory);
BoolectorQuantifiedFormulaManager quantifierTheory =
new BoolectorQuantifiedFormulaManager(creator);
BoolectorArrayFormulaManager arrayTheory = new BoolectorArrayFormulaManager(creator);
BoolectorFormulaManager manager =
new BoolectorFormulaManager(
creator, functionTheory, booleanTheory, bitvectorTheory, quantifierTheory, arrayTheory);
return new BoolectorSolverContext(manager, creator, pShutdownNotifier);
}
@Override
public String getVersion() {
return "Boolector " + BtorJNI.boolector_version(creator.getEnv());
}
@Override
public Solvers getSolverName() {
return Solvers.BOOLECTOR;
}
/**
* Boolector returns a pre-formatted text for statistics. We might need to parse it. Example:
*
* <pre>
* [btor>sat] 15 SAT calls in 0,0 seconds
* [btor>core] 0/0/0/0 constraints 0/0/0/0 0,0 MB
* [btor>core] 10 assumptions
* [btor>core]
* [btor>core] 0 max rec. RW
* [btor>core] 67 number of expressions ever created
* [btor>core] 67 number of final expressions
* [btor>core] 0,01 MB allocated for nodes
* [btor>core] bvconst: 5 max 5
* [btor>core] var: 6 max 6
* [btor>core] slice: 6 max 6
* [btor>core] and: 35 max 35
* [btor>core] beq: 13 max 13
* [btor>core] ult: 2 max 2
* [btor>core]
* [btor>core] 0 variable substitutions
* [btor>core] 0 uninterpreted function substitutions
* [btor>core] 0 embedded constraint substitutions
* [btor>core] 0 synthesized nodes rewritten
* [btor>core] 0 linear constraint equations
* [btor>core] 0 gaussian eliminations in linear equations
* [btor>core] 0 eliminated sliced variables
* [btor>core] 0 extracted skeleton constraints
* [btor>core] 0 and normalizations
* [btor>core] 0 add normalizations
* [btor>core] 0 mul normalizations
* [btor>core] 0 lambdas merged
* [btor>core] 0 static apply propagations over lambdas
* [btor>core] 0 static apply propagations over updates
* [btor>core] 0 beta reductions
* [btor>core] 0 clone calls
* [btor>core]
* [btor>core] rewrite rule cache
* [btor>core] 0 cached (add)
* [btor>core] 0 cached (get)
* [btor>core] 0 updated
* [btor>core] 0 removed (gc)
* [btor>core] 0,00 MB cache
* [btor>core]
* [btor>core] bit blasting statistics:
* [btor>core] 65 AIG vectors (65 max)
* [btor>core] 35 AIG ANDs (35 max)
* [btor>core] 12 AIG variables
* [btor>core] 45 CNF variables
* [btor>core] 100 CNF clauses
* [btor>core] 236 CNF literals
* [btor>slvfun]
* [btor>slvfun] 0 expression evaluations
* [btor>slvfun] 0 partial beta reductions
* [btor>slvfun] 0 propagations
* [btor>slvfun] 0 propagations down
* [btor>core]
* [btor>core] 0,0 MB
* </pre>
*/
@Override
public ImmutableMap<String, String> getStatistics() {
// get plain statistics
final long env = creator.getEnv();
BtorJNI.boolector_set_opt(env, BtorOption.BTOR_OPT_VERBOSITY.getValue(), 3);
String stats = BtorJNI.boolector_print_stats_helper(env);
BtorJNI.boolector_set_opt(env, BtorOption.BTOR_OPT_VERBOSITY.getValue(), 0);
// then parse them into a map
// TODO ... forget it, Boolector dumps it in human-readable form,
// there is no simple way of converting it into a key-value-mapping.
return ImmutableMap.of("statistics", stats);
}
@Override
public void close() {
if (!closed) {
closed = true;
BtorJNI.boolector_delete(creator.getEnv());
}
}
@SuppressWarnings("resource")
@Override
protected ProverEnvironment newProverEnvironment0(Set<ProverOptions> pOptions) {
Preconditions.checkState(!closed, "solver context is already closed");
return new BoolectorTheoremProver(
manager, creator, creator.getEnv(), shutdownNotifier, pOptions, isAnyStackAlive);
}
@Override
protected InterpolatingProverEnvironment<?> newProverEnvironmentWithInterpolation0(
Set<ProverOptions> pSet) {
throw new UnsupportedOperationException("Boolector does not support interpolation");
}
@Override
protected OptimizationProverEnvironment newOptimizationProverEnvironment0(
Set<ProverOptions> pSet) {
throw new UnsupportedOperationException("Boolector does not support optimization");
}
@Override
protected boolean supportsAssumptionSolving() {
return true;
}
/** set basic options for running Boolector. */
private static void setOptions(
Configuration config, PathCounterTemplate solverLogfile, long randomSeed, long btor)
throws InvalidConfigurationException {
BoolectorSettings settings = new BoolectorSettings(config);
Preconditions.checkNotNull(settings.satSolver);
BtorJNI.boolector_set_sat_solver(
btor, settings.satSolver.name().toLowerCase(Locale.getDefault()));
// Default Options to enable multiple SAT, auto cleanup on close, incremental mode
BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_MODEL_GEN.getValue(), 2);
// Auto memory clean after closing
BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_AUTO_CLEANUP.getValue(), 1);
// Incremental needed for push/pop!
BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_INCREMENTAL.getValue(), 1);
// Sets randomseed accordingly
BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_SEED.getValue(), randomSeed);
// Dump in SMT-LIB2 Format
BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_OUTPUT_FORMAT.getValue(), 2);
// Stop Boolector from rewriting formulas in outputs
BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_REWRITE_LEVEL.getValue(), 0);
setFurtherOptions(btor, settings.furtherOptions);
if (solverLogfile != null) {
String filename = solverLogfile.getFreshPath().toAbsolutePath().toString();
BtorJNI.boolector_set_trapi(btor, filename);
}
}
/**
* Set more options for Boolector.
*
* @param btor solver instance.
* @param pFurtherOptions String to be parsed with options to be set.
* @throws InvalidConfigurationException signals that the format of the option string is wrong or
* an invalid option is used.
*/
private static void setFurtherOptions(long btor, String pFurtherOptions)
throws InvalidConfigurationException {
MapSplitter optionSplitter =
Splitter.on(',')
.trimResults()
.omitEmptyStrings()
.withKeyValueSeparator(Splitter.on('=').limit(2).trimResults());
ImmutableMap<String, String> furtherOptionsMap;
try {
furtherOptionsMap = ImmutableMap.copyOf(optionSplitter.split(pFurtherOptions));
} catch (IllegalArgumentException e) {
throw new InvalidConfigurationException(
"Invalid Boolector option in \"" + pFurtherOptions + "\": " + e.getMessage(), e);
}
for (Map.Entry<String, String> option : furtherOptionsMap.entrySet()) {
try {
BtorOption btorOption = BtorOption.valueOf(option.getKey());
long optionValue = Long.parseLong(option.getValue());
BtorJNI.boolector_set_opt(btor, btorOption.getValue(), optionValue);
} catch (IllegalArgumentException e) {
throw new InvalidConfigurationException(e.getMessage(), e);
}
}
}
}
| 10,904 | 36.864583 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorTheoremProver.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.boolector;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.java_smt.api.ProverEnvironment;
import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
class BoolectorTheoremProver extends BoolectorAbstractProver<Void> implements ProverEnvironment {
// Used as standard prover. Built by method newProverEnvironment0 in BtorSolverContext
protected BoolectorTheoremProver(
BoolectorFormulaManager manager,
BoolectorFormulaCreator creator,
long btor,
ShutdownNotifier pShutdownNotifier,
Set<ProverOptions> pOptions,
AtomicBoolean pIsAnyStackAlive) {
super(manager, creator, btor, pShutdownNotifier, pOptions, pIsAnyStackAlive);
}
}
| 1,046 | 33.9 | 97 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorUFManager.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.boolector;
import org.sosy_lab.java_smt.basicimpl.AbstractUFManager;
final class BoolectorUFManager extends AbstractUFManager<Long, Long, Long, Long> {
BoolectorUFManager(BoolectorFormulaCreator pCreator) {
super(pCreator);
}
}
| 517 | 26.263158 | 82 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BtorJNI.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// This file is based on an automatically generated file produced by SWIG
// (http://www.swig.org, version 4.0.0) in Boolector, and then edited manually.
//
// SPDX-FileCopyrightText: 2007-2020 Dirk Beyer <https://www.sosy-lab.org>
// SPDX-FileCopyrightText: 2015-2020 Mathias Preiner
// SPDX-FileCopyrightText: 2016 Armin Biere
// SPDX-FileCopyrightText: 2016-2020 Aina Niemetz
//
// SPDX-License-Identifier: MIT AND Apache-2.0
package org.sosy_lab.java_smt.solvers.boolector;
/** Native code for Boolector methods. */
@SuppressWarnings({"unused", "checkstyle:methodname", "checkstyle:parametername"})
class BtorJNI {
private BtorJNI() {}
protected static native int BOOLECTOR_PARSE_ERROR_get();
protected static native int BOOLECTOR_PARSE_UNKNOWN_get();
protected static native long boolector_new();
protected static native long boolector_clone(long jarg1);
protected static native void boolector_delete(long jarg1);
protected static native void boolector_set_term(long jarg1, long jarg2, long jarg3);
protected static native int boolector_terminate(long jarg1);
protected static native void boolector_set_abort(long jarg1);
protected static native void boolector_set_msg_prefix(long jarg1, String jarg2);
protected static native int boolector_get_refs(long jarg1);
protected static native void boolector_reset_time(long jarg1);
protected static native void boolector_reset_stats(long jarg1);
protected static native void boolector_print_stats(long jarg1);
/**
* See Boolector API. (Enables trace of API to given file).
*
* @param jarg1 btor
* @param jarg2 absolute path to the trace file
*/
protected static native void boolector_set_trapi(long jarg1, String jarg2);
protected static native long boolector_get_trapi(long jarg1);
protected static native void boolector_push(long jarg1, long jarg2);
protected static native void boolector_pop(long jarg1, long jarg2);
protected static native void boolector_assert(long jarg1, long jarg2);
protected static native void boolector_assume(long jarg1, long jarg2);
protected static native boolean boolector_failed(long jarg1, long jarg2);
protected static native long boolector_get_failed_assumptions(long jarg1);
protected static native void boolector_fixate_assumptions(long jarg1);
protected static native void boolector_reset_assumptions(long jarg1);
protected static native int boolector_sat(long jarg1);
protected static native int boolector_limited_sat(long jarg1, long jarg2, long jarg3);
protected static native int boolector_simplify(long jarg1);
protected static native void boolector_set_sat_solver(long jarg1, String jarg2);
protected static native void boolector_set_opt(long jarg1, int jarg2, long jarg3);
protected static native int boolector_get_opt(long jarg1, int jarg2);
protected static native int boolector_get_opt_min(long jarg1, int jarg2);
protected static native int boolector_get_opt_max(long jarg1, int jarg2);
protected static native int boolector_get_opt_dflt(long jarg1, int jarg2);
protected static native String boolector_get_opt_lng(long jarg1, int jarg2);
protected static native String boolector_get_opt_shrt(long jarg1, int jarg2);
protected static native String boolector_get_opt_desc(long jarg1, int jarg2);
protected static native boolean boolector_has_opt(long jarg1, int jarg2);
protected static native int boolector_first_opt(long jarg1);
protected static native int boolector_next_opt(long jarg1, int jarg2);
protected static native long boolector_copy(long jarg1, long jarg2);
protected static native void boolector_release(long jarg1, long jarg2);
protected static native void boolector_release_all(long jarg1);
protected static native long boolector_true(long jarg1);
protected static native long boolector_false(long jarg1);
protected static native long boolector_implies(long jarg1, long jarg2, long jarg3);
protected static native long boolector_iff(long jarg1, long jarg2, long jarg3);
protected static native long boolector_eq(long jarg1, long jarg2, long jarg3);
protected static native long boolector_ne(long jarg1, long jarg2, long jarg3);
protected static native boolean boolector_is_bv_const_zero(long jarg1, long jarg2);
protected static native boolean boolector_is_bv_const_one(long jarg1, long jarg2);
protected static native boolean boolector_is_bv_const_ones(long jarg1, long jarg2);
protected static native boolean boolector_is_bv_const_max_signed(long jarg1, long jarg2);
protected static native boolean boolector_is_bv_const_min_signed(long jarg1, long jarg2);
protected static native long boolector_const(long jarg1, String jarg2);
protected static native long boolector_constd(long jarg1, long jarg2, String jarg3);
protected static native long boolector_consth(long jarg1, long jarg2, String jarg3);
protected static native long boolector_zero(long jarg1, long jarg2);
protected static native long boolector_ones(long jarg1, long jarg2);
protected static native long boolector_one(long jarg1, long jarg2);
protected static native long boolector_min_signed(long jarg1, long jarg2);
protected static native long boolector_max_signed(long jarg1, long jarg2);
protected static native long boolector_unsigned_int(long jarg1, long jarg2, long jarg3);
protected static native long boolector_int(long jarg1, long jarg2, long jarg3);
protected static native long boolector_var(long jarg1, long jarg2, String jarg3);
protected static native long boolector_array(long jarg1, long jarg2, String jarg3);
protected static native long boolector_uf(long jarg1, long jarg2, String jarg3);
protected static native long boolector_not(long jarg1, long jarg2);
protected static native long boolector_neg(long jarg1, long jarg2);
protected static native long boolector_redor(long jarg1, long jarg2);
protected static native long boolector_redxor(long jarg1, long jarg2);
protected static native long boolector_redand(long jarg1, long jarg2);
protected static native long boolector_slice(long jarg1, long jarg2, long jarg3, long jarg4);
protected static native long boolector_uext(long jarg1, long jarg2, long jarg3);
protected static native long boolector_sext(long jarg1, long jarg2, long jarg3);
protected static native long boolector_xor(long jarg1, long jarg2, long jarg3);
protected static native long boolector_xnor(long jarg1, long jarg2, long jarg3);
protected static native long boolector_and(long jarg1, long jarg2, long jarg3);
protected static native long boolector_nand(long jarg1, long jarg2, long jarg3);
protected static native long boolector_or(long jarg1, long jarg2, long jarg3);
protected static native long boolector_nor(long jarg1, long jarg2, long jarg3);
protected static native long boolector_add(long jarg1, long jarg2, long jarg3);
protected static native long boolector_uaddo(long jarg1, long jarg2, long jarg3);
protected static native long boolector_saddo(long jarg1, long jarg2, long jarg3);
protected static native long boolector_mul(long jarg1, long jarg2, long jarg3);
protected static native long boolector_umulo(long jarg1, long jarg2, long jarg3);
protected static native long boolector_smulo(long jarg1, long jarg2, long jarg3);
protected static native long boolector_ult(long jarg1, long jarg2, long jarg3);
protected static native long boolector_slt(long jarg1, long jarg2, long jarg3);
protected static native long boolector_ulte(long jarg1, long jarg2, long jarg3);
protected static native long boolector_slte(long jarg1, long jarg2, long jarg3);
protected static native long boolector_ugt(long jarg1, long jarg2, long jarg3);
protected static native long boolector_sgt(long jarg1, long jarg2, long jarg3);
protected static native long boolector_ugte(long jarg1, long jarg2, long jarg3);
protected static native long boolector_sgte(long jarg1, long jarg2, long jarg3);
protected static native long boolector_sll(long jarg1, long jarg2, long jarg3);
protected static native long boolector_srl(long jarg1, long jarg2, long jarg3);
protected static native long boolector_sra(long jarg1, long jarg2, long jarg3);
protected static native long boolector_rol(long jarg1, long jarg2, long jarg3);
protected static native long boolector_ror(long jarg1, long jarg2, long jarg3);
protected static native long boolector_sub(long jarg1, long jarg2, long jarg3);
protected static native long boolector_usubo(long jarg1, long jarg2, long jarg3);
protected static native long boolector_ssubo(long jarg1, long jarg2, long jarg3);
protected static native long boolector_udiv(long jarg1, long jarg2, long jarg3);
protected static native long boolector_sdiv(long jarg1, long jarg2, long jarg3);
protected static native long boolector_sdivo(long jarg1, long jarg2, long jarg3);
protected static native long boolector_urem(long jarg1, long jarg2, long jarg3);
protected static native long boolector_srem(long jarg1, long jarg2, long jarg3);
protected static native long boolector_smod(long jarg1, long jarg2, long jarg3);
protected static native long boolector_concat(long jarg1, long jarg2, long jarg3);
protected static native long boolector_repeat(long jarg1, long jarg2, long jarg3);
protected static native long boolector_read(long jarg1, long jarg2, long jarg3);
protected static native long boolector_write(long jarg1, long jarg2, long jarg3, long jarg4);
protected static native long boolector_cond(long jarg1, long jarg2, long jarg3, long jarg4);
protected static native long boolector_param(long jarg1, long jarg2, String jarg3);
protected static native long boolector_fun(long jarg1, long jarg2, long jarg3, long jarg4);
protected static native long boolector_apply(
long btor, long[] argumentNodes, long numberOfArguments, long functionNode);
protected static native long boolector_inc(long jarg1, long jarg2);
protected static native long boolector_dec(long jarg1, long jarg2);
protected static native long boolector_forall(long jarg1, long[] jarg2, long jarg3, long jarg4);
protected static native long boolector_exists(long jarg1, long[] jarg2, long jarg3, long jarg4);
protected static native long boolector_get_btor(long jarg1);
protected static native int boolector_get_node_id(long jarg1, long jarg2);
protected static native long boolector_get_sort(long jarg1, long jarg2);
protected static native long boolector_fun_get_domain_sort(long jarg1, long jarg2);
protected static native long boolector_fun_get_codomain_sort(long jarg1, long jarg2);
protected static native long boolector_match_node_by_id(long jarg1, long jarg2);
protected static native long boolector_match_node_by_symbol(long jarg1, String jarg2);
protected static native long boolector_match_node(long jarg1, long jarg2);
protected static native String boolector_get_symbol(long jarg1, long jarg2);
protected static native void boolector_set_symbol(long jarg1, long jarg2, String jarg3);
protected static native int boolector_get_width(long jarg1, long jarg2);
protected static native int boolector_get_index_width(long jarg1, long jarg2);
protected static native String boolector_get_bits(long jarg1, long jarg2);
protected static native void boolector_free_bits(long jarg1, String jarg2);
protected static native int boolector_get_fun_arity(long jarg1, long jarg2);
protected static native boolean boolector_is_const(long jarg1, long jarg2);
protected static native boolean boolector_is_var(long jarg1, long jarg2);
protected static native boolean boolector_is_array(long jarg1, long jarg2);
protected static native boolean boolector_is_array_var(long jarg1, long jarg2);
protected static native boolean boolector_is_param(long jarg1, long jarg2);
protected static native boolean boolector_is_bound_param(long jarg1, long jarg2);
protected static native boolean boolector_is_uf(long jarg1, long jarg2);
protected static native boolean boolector_is_fun(long jarg1, long jarg2);
protected static native int boolector_fun_sort_check(
long jarg1, long[] jarg2, long jarg3, long jarg4);
protected static native String boolector_bv_assignment(long jarg1, long jarg2);
protected static native void boolector_free_bv_assignment(long jarg1, String jarg2);
// Use the helper method instead of this one!
protected static native void boolector_array_assignment(
long btor, long array_operand, long indicies, long values, long size);
protected static native void boolector_free_array_assignment(
long jarg1, long jarg2, long jarg3, long jarg4);
// Use the helper method instead of this one!
protected static native void boolector_uf_assignment(
long jarg1, long jarg2, long jarg3, long jarg4, long jarg5);
protected static native void boolector_free_uf_assignment(
long jarg1, long jarg2, long jarg3, long jarg4);
protected static native void boolector_print_model(long jarg1, String jarg2, long jarg3);
protected static native long boolector_bool_sort(long jarg1);
protected static native long boolector_bitvec_sort(long jarg1, long jarg2);
protected static native long boolector_fun_sort(
long btor, long[] argumentSorts, long arity, long returnSort);
protected static native long boolector_array_sort(long jarg1, long jarg2, long jarg3);
protected static native long boolector_copy_sort(long jarg1, long jarg2);
protected static native void boolector_release_sort(long jarg1, long jarg2);
protected static native boolean boolector_is_equal_sort(long jarg1, long jarg2, long jarg3);
protected static native boolean boolector_is_array_sort(long jarg1, long jarg2);
protected static native boolean boolector_is_bitvec_sort(long jarg1, long jarg2);
protected static native boolean boolector_is_fun_sort(long jarg1, long jarg2);
// Use the helper method instead of this one!
protected static native long boolector_parse(
long jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6);
protected static native int boolector_parse_btor(
long jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6);
protected static native int boolector_parse_btor2(
long jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6);
protected static native int boolector_parse_smt1(
long jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6);
protected static native int boolector_parse_smt2(
long jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6);
protected static native void boolector_dump_btor_node(long jarg1, long jarg2, long jarg3);
protected static native void boolector_dump_btor(long jarg1, long jarg2);
// Use the helper method instead of this one!
protected static native void boolector_dump_smt2_node(long jarg1, long jarg2, long jarg3);
// Use the helper method instead of this one!
protected static native void boolector_dump_smt2(long jarg1, long jarg2);
protected static native void boolector_dump_aiger_ascii(long jarg1, long jarg2, boolean jarg3);
protected static native void boolector_dump_aiger_binary(long jarg1, long jarg2, boolean jarg3);
protected static native String boolector_copyright(long jarg1);
protected static native String boolector_version(long jarg1);
protected static native String boolector_git_id(long jarg1);
protected static native int BTOR_RESULT_SAT_get();
protected static native int BTOR_RESULT_UNSAT_get();
protected static native int BTOR_RESULT_UNKNOWN_get();
protected static native void BtorAbortCallback_abort_fun_set(long jarg1, long jarg2);
protected static native long BtorAbortCallback_abort_fun_get(long jarg1);
protected static native void BtorAbortCallback_cb_fun_set(long jarg1, long jarg2);
protected static native long BtorAbortCallback_cb_fun_get(long jarg1);
protected static native long new_BtorAbortCallback();
protected static native void delete_BtorAbortCallback(long jarg1);
protected static native void btor_abort_callback_set(long jarg1);
protected static native long btor_abort_callback_get();
protected static native int boolector_bitvec_sort_get_width(long jarg1, long jarg2);
protected static native long boolector_roli(long btor, long node, int nbits);
protected static native long boolector_rori(long btor, long node, int nbits);
protected static native long boolector_get_value(long btor, long node);
/**
* Returns int representation of BOOLECTOR_PARSE_ERROR. Used for checking return value of
* boolector_help_parse().
*
* @return int BOOLECTOR_PARSE_UNKNOWN
*/
protected static native int boolector_help_get_parse_error();
/**
* Returns int representation of BOOLECTOR_PARSE_UNKNOWN. Used for checking return value of
* boolector_help_parse().
*
* @return int BOOLECTOR_PARSE_UNKNOWN
*/
protected static native int boolector_help_get_parse_unknown();
/**
* Returns string dump in smt2 format of the entire formula. No guarantee that that string is
* useful.
*
* @param jarg1 btor (environment)
* @return string dump of btor instance
*/
protected static native String boolector_help_dump_smt2(long jarg1);
/**
* Returns string dump in smt2 format from btor instance of the chosen node. No guarantee that
* that string is useful
*
* @param jarg1 btor (environment)
* @param jarg2 node to dump
* @return string dump of the node
*/
protected static native String boolector_help_dump_node_smt2(long jarg1, long jarg2);
/**
* Tries to parse the string into boolector.
*
* @param jarg1 btor
* @param jarg2 string to parse
* @return String[5] with following contents in that order (original data-type in brackets): 1.
* return value (int); 2. outputfile (String); 3. error_msg(String); 4. status(int); 5.
* parsed_smt2(Bool as 1(true) or 0(false))
*/
protected static native String[] boolector_help_parse(long jarg1, String jarg2);
/**
* Gives back the assignment of the array node entered. Return will be arguments and assignments
* in 2 string arrays in an array.
*
* @param btor btor instance
* @param arrayNode array node
* @return Returns 2Dim Array or Strings. Size [2][x], x beeing the length of the array used.
* First String Array will be argument assignment strings. Second String Array will be value
* assignment strings. Example: array[0][0] is the index to value array[1][0]. Note: repeated
* calls to this might change the order of the arrays (but uniformly across both).
*/
protected static native String[][] boolector_array_assignment_helper(long btor, long arrayNode);
/**
* Returns the assignment of the UF node in 2 string arrays in an array length 2.
*
* @param btor btor instance
* @param ufNode array node
* @return Returns 2Dim Array or Strings. Size [2][x], x being the length of the uf used. First
* String Array will be argument assignment strings. For multiple arguments, the argument
* values are seperated by a single space in the same String! Second String Array will be
* value assignment strings.
*/
protected static native String[][] boolector_uf_assignment_helper(long btor, long ufNode);
/**
* Helper method for boolector_print_stats() that does not print to the commandline. This needs
* verbosity level 3 or more! Since this prints debug info all the time it is recommended to set
* the option to 3 before using this and setting it back to 0 afterwards.
*
* @param btor boolector instance.
* @return a String representing the stats that Boolector gives out.
*/
protected static native String boolector_print_stats_helper(long btor);
/**
* Sets termination callback to chosen implementation of a method.
*
* @param btor instance
* @param terminationCallback TerminationCallback method
* @return address to helper struct. Call method boolector_free_termination with it to free its
* ressources after termination!
*/
protected static native long boolector_set_termination(
long btor, TerminationCallback terminationCallback);
/**
* Frees resources of the termination callback function. Call ONLY after termination has occured
* with the return value of boolector_set_termination of its instance!
*
* @param helper address to helper struct used in termination callback.
*/
protected static native void boolector_free_termination(long helper);
/** This is used to get the methodID for the JNI call to the termination callback method. */
interface TerminationCallback {
boolean shouldTerminate() throws InterruptedException;
}
}
| 20,972 | 38.721591 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/BtorOption.java | // This file is part of JavaSMT,
// an API wrapper for a collection of SMT solvers:
// https://github.com/sosy-lab/java-smt
//
// This file is based on "btortypes.h" from Boolector.
//
// SPDX-FileCopyrightText: 2007-2020 Dirk Beyer <https://www.sosy-lab.org>
// SPDX-FileCopyrightText: 2015-2020 Mathias Preiner
// SPDX-FileCopyrightText: 2016 Armin Biere
// SPDX-FileCopyrightText: 2016-2020 Aina Niemetz
//
// SPDX-License-Identifier: MIT AND Apache-2.0
package org.sosy_lab.java_smt.solvers.boolector;
/** We keep this synchronized with "btortypes.h". */
public enum BtorOption {
BTOR_OPT_MODEL_GEN,
BTOR_OPT_INCREMENTAL,
BTOR_OPT_INCREMENTAL_SMT1,
BTOR_OPT_INPUT_FORMAT,
BTOR_OPT_OUTPUT_NUMBER_FORMAT,
BTOR_OPT_OUTPUT_FORMAT,
BTOR_OPT_ENGINE,
BTOR_OPT_SAT_ENGINE,
BTOR_OPT_AUTO_CLEANUP,
BTOR_OPT_PRETTY_PRINT,
BTOR_OPT_EXIT_CODES,
BTOR_OPT_SEED,
BTOR_OPT_VERBOSITY,
BTOR_OPT_LOGLEVEL,
BTOR_OPT_REWRITE_LEVEL,
BTOR_OPT_SKELETON_PREPROC,
BTOR_OPT_ACKERMANN,
BTOR_OPT_BETA_REDUCE,
BTOR_OPT_ELIMINATE_SLICES,
BTOR_OPT_VAR_SUBST,
BTOR_OPT_UCOPT,
BTOR_OPT_MERGE_LAMBDAS,
BTOR_OPT_EXTRACT_LAMBDAS,
BTOR_OPT_NORMALIZE,
BTOR_OPT_NORMALIZE_ADD,
BTOR_OPT_FUN_PREPROP,
BTOR_OPT_FUN_PRESLS,
BTOR_OPT_FUN_DUAL_PROP,
BTOR_OPT_FUN_DUAL_PROP_QSORT,
BTOR_OPT_FUN_JUST,
BTOR_OPT_FUN_JUST_HEURISTIC,
BTOR_OPT_FUN_LAZY_SYNTHESIZE,
BTOR_OPT_FUN_EAGER_LEMMAS,
BTOR_OPT_FUN_STORE_LAMBDAS,
BTOR_OPT_PRINT_DIMACS,
BTOR_OPT_SLS_NFLIPS,
BTOR_OPT_SLS_STRATEGY,
BTOR_OPT_SLS_JUST,
BTOR_OPT_SLS_MOVE_GW,
BTOR_OPT_SLS_MOVE_RANGE,
BTOR_OPT_SLS_MOVE_SEGMENT,
BTOR_OPT_SLS_MOVE_RAND_WALK,
BTOR_OPT_SLS_PROB_MOVE_RAND_WALK,
BTOR_OPT_SLS_MOVE_RAND_ALL,
BTOR_OPT_SLS_MOVE_RAND_RANGE,
BTOR_OPT_SLS_MOVE_PROP,
BTOR_OPT_SLS_MOVE_PROP_N_PROP,
BTOR_OPT_SLS_MOVE_PROP_N_SLS,
BTOR_OPT_SLS_MOVE_PROP_FORCE_RW,
BTOR_OPT_SLS_MOVE_INC_MOVE_TEST,
BTOR_OPT_SLS_USE_RESTARTS,
BTOR_OPT_SLS_USE_BANDIT,
BTOR_OPT_PROP_NPROPS,
BTOR_OPT_PROP_USE_RESTARTS,
BTOR_OPT_PROP_USE_BANDIT,
BTOR_OPT_PROP_PATH_SEL,
BTOR_OPT_PROP_PROB_USE_INV_VALUE,
BTOR_OPT_PROP_PROB_FLIP_COND,
BTOR_OPT_PROP_PROB_FLIP_COND_CONST,
BTOR_OPT_PROP_FLIP_COND_CONST_DELTA,
BTOR_OPT_PROP_FLIP_COND_CONST_NPATHSEL,
BTOR_OPT_PROP_PROB_SLICE_KEEP_DC,
BTOR_OPT_PROP_PROB_CONC_FLIP,
BTOR_OPT_PROP_PROB_SLICE_FLIP,
BTOR_OPT_PROP_PROB_EQ_FLIP,
BTOR_OPT_PROP_PROB_AND_FLIP,
BTOR_OPT_PROP_NO_MOVE_ON_CONFLICT,
BTOR_OPT_AIGPROP_USE_RESTARTS,
BTOR_OPT_AIGPROP_USE_BANDIT,
BTOR_OPT_QUANT_SYNTH,
BTOR_OPT_QUANT_DUAL_SOLVER,
BTOR_OPT_QUANT_SYNTH_LIMIT,
BTOR_OPT_QUANT_SYNTH_QI,
BTOR_OPT_QUANT_DER,
BTOR_OPT_QUANT_CER,
BTOR_OPT_QUANT_MINISCOPE,
BTOR_OPT_SORT_EXP,
BTOR_OPT_SORT_AIG,
BTOR_OPT_SORT_AIGVEC,
BTOR_OPT_AUTO_CLEANUP_INTERNAL,
BTOR_OPT_SIMPLIFY_CONSTRAINTS,
BTOR_OPT_CHK_FAILED_ASSUMPTIONS,
BTOR_OPT_CHK_MODEL,
BTOR_OPT_CHK_UNCONSTRAINED,
BTOR_OPT_PARSE_INTERACTIVE,
BTOR_OPT_SAT_ENGINE_LGL_FORK,
BTOR_OPT_SAT_ENGINE_CADICAL_FREEZE,
BTOR_OPT_SAT_ENGINE_N_THREADS,
BTOR_OPT_SIMP_NORMAMLIZE_ADDERS,
BTOR_OPT_DECLSORT_BV_WIDTH,
BTOR_OPT_QUANT_SYNTH_ITE_COMPLETE,
BTOR_OPT_QUANT_FIXSYNTH,
BTOR_OPT_RW_ZERO_LOWER_SLICE,
BTOR_OPT_NONDESTR_SUBST;
private static class EnumIndexCounter {
private static int nextValue = 0;
}
private final int value;
BtorOption() {
value = EnumIndexCounter.nextValue++;
}
public final int getValue() {
return value;
}
@Override
public String toString() {
return name() + "(" + getValue() + ")";
}
}
| 3,566 | 26.022727 | 74 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/boolector/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 Boolector (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.boolector;
| 595 | 38.733333 | 81 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4ArrayFormulaManager.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.cvc4;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.Kind;
import edu.stanford.CVC4.Type;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.FormulaType.ArrayFormulaType;
import org.sosy_lab.java_smt.basicimpl.AbstractArrayFormulaManager;
public class CVC4ArrayFormulaManager
extends AbstractArrayFormulaManager<Expr, Type, ExprManager, Expr> {
private final ExprManager exprManager;
public CVC4ArrayFormulaManager(CVC4FormulaCreator pFormulaCreator) {
super(pFormulaCreator);
exprManager = pFormulaCreator.getEnv();
}
@Override
protected Expr select(Expr pArray, Expr pIndex) {
return exprManager.mkExpr(Kind.SELECT, pArray, pIndex);
}
@Override
protected Expr store(Expr pArray, Expr pIndex, Expr pValue) {
return exprManager.mkExpr(Kind.STORE, pArray, pIndex, pValue);
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TI extends Formula, TE extends Formula> Expr internalMakeArray(
String pName, FormulaType<TI> pIndexType, FormulaType<TE> pElementType) {
final ArrayFormulaType<TI, TE> arrayFormulaType =
FormulaType.getArrayType(pIndexType, pElementType);
final Type cvc4ArrayType = toSolverType(arrayFormulaType);
return getFormulaCreator().makeVariable(cvc4ArrayType, pName);
}
@Override
protected Expr equivalence(Expr pArray1, Expr pArray2) {
return exprManager.mkExpr(Kind.EQUAL, pArray1, pArray2);
}
}
| 1,817 | 32.054545 | 79 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4BitvectorFormulaManager.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.cvc4;
import edu.stanford.CVC4.BitVector;
import edu.stanford.CVC4.BitVectorExtract;
import edu.stanford.CVC4.BitVectorSignExtend;
import edu.stanford.CVC4.BitVectorType;
import edu.stanford.CVC4.BitVectorZeroExtend;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.IntToBitVector;
import edu.stanford.CVC4.Kind;
import edu.stanford.CVC4.Rational;
import edu.stanford.CVC4.Type;
import edu.stanford.CVC4.vectorExpr;
import java.math.BigInteger;
import java.util.List;
import org.sosy_lab.java_smt.api.FormulaType.BitvectorType;
import org.sosy_lab.java_smt.basicimpl.AbstractBitvectorFormulaManager;
public class CVC4BitvectorFormulaManager
extends AbstractBitvectorFormulaManager<Expr, Type, ExprManager, Expr> {
private final ExprManager exprManager;
protected CVC4BitvectorFormulaManager(
CVC4FormulaCreator pCreator, CVC4BooleanFormulaManager pBmgr) {
super(pCreator, pBmgr);
exprManager = pCreator.getEnv();
}
@Override
protected Expr concat(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.BITVECTOR_CONCAT, pParam1, pParam2);
}
@Override
protected Expr extract(Expr pParam1, int pMsb, int pLsb) {
Expr ext = exprManager.mkConst(new BitVectorExtract(pMsb, pLsb));
return exprManager.mkExpr(Kind.BITVECTOR_EXTRACT, ext, pParam1);
}
@Override
protected Expr extend(Expr pParam1, int pExtensionBits, boolean signed) {
final Expr op;
if (signed) {
op = exprManager.mkConst(new BitVectorSignExtend(pExtensionBits));
} else {
op = exprManager.mkConst(new BitVectorZeroExtend(pExtensionBits));
}
return exprManager.mkExpr(op, pParam1);
}
@Override
protected Expr makeBitvectorImpl(int pLength, BigInteger pI) {
pI = transformValueToRange(pLength, pI);
return exprManager.mkConst(new BitVector(pLength, pI));
}
@Override
protected Expr makeVariableImpl(int length, String varName) {
Type type = exprManager.mkBitVectorType(length);
return getFormulaCreator().makeVariable(type, varName);
}
@Override
protected Expr shiftRight(Expr pParam1, Expr pParam2, boolean signed) {
if (signed) {
return exprManager.mkExpr(Kind.BITVECTOR_ASHR, pParam1, pParam2);
} else {
return exprManager.mkExpr(Kind.BITVECTOR_LSHR, pParam1, pParam2);
}
}
@Override
protected Expr shiftLeft(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.BITVECTOR_SHL, pParam1, pParam2);
}
@Override
protected Expr not(Expr pParam1) {
return exprManager.mkExpr(Kind.BITVECTOR_NOT, pParam1);
}
@Override
protected Expr and(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.BITVECTOR_AND, pParam1, pParam2);
}
@Override
protected Expr or(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.BITVECTOR_OR, pParam1, pParam2);
}
@Override
protected Expr xor(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.BITVECTOR_XOR, pParam1, pParam2);
}
@Override
protected Expr negate(Expr pParam1) {
return exprManager.mkExpr(Kind.BITVECTOR_NEG, pParam1);
}
@Override
protected Expr add(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.BITVECTOR_PLUS, pParam1, pParam2);
}
@Override
protected Expr subtract(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.BITVECTOR_SUB, pParam1, pParam2);
}
@Override
protected Expr divide(Expr numerator, Expr denumerator, boolean signed) {
final Kind operator = signed ? Kind.BITVECTOR_SDIV : Kind.BITVECTOR_UDIV;
final Expr division = exprManager.mkExpr(operator, numerator, denumerator);
// CVC4 does not align with SMTLIB standard when it comes to divide-by-zero.
// For divide-by-zero, we compute the result as: return "1" with the opposite
// sign than the numerator.
final int bitsize = ((BitvectorType) formulaCreator.getFormulaType(numerator)).getSize();
final Expr zero = makeBitvectorImpl(bitsize, 0);
final Expr one = makeBitvectorImpl(bitsize, 1);
final Expr maxValue = makeBitvectorImpl(bitsize, -1); // all bits equal "1"
return exprManager.mkExpr(
Kind.ITE,
exprManager.mkExpr(Kind.EQUAL, denumerator, zero),
exprManager.mkExpr(Kind.ITE, lessThan(numerator, zero, signed), one, maxValue),
division);
}
@Override
protected Expr modulo(Expr numerator, Expr denumerator, boolean signed) {
final Kind operator = signed ? Kind.BITVECTOR_SREM : Kind.BITVECTOR_UREM;
final Expr remainder = exprManager.mkExpr(operator, numerator, denumerator);
// CVC4 does not align with SMTLIB standard when it comes to modulo-by-zero.
// For modulo-by-zero, we compute the result as: "return the numerator".
final int bitsize = ((BitvectorType) formulaCreator.getFormulaType(numerator)).getSize();
final Expr zero = makeBitvectorImpl(bitsize, 0);
return exprManager.mkExpr(
Kind.ITE, exprManager.mkExpr(Kind.EQUAL, denumerator, zero), numerator, remainder);
}
@Override
protected Expr multiply(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.BITVECTOR_MULT, pParam1, pParam2);
}
@Override
protected Expr equal(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.EQUAL, pParam1, pParam2);
}
@Override
protected Expr lessThan(Expr pParam1, Expr pParam2, boolean signed) {
if (signed) {
return exprManager.mkExpr(Kind.BITVECTOR_SLT, pParam1, pParam2);
} else {
return exprManager.mkExpr(Kind.BITVECTOR_ULT, pParam1, pParam2);
}
}
@Override
protected Expr lessOrEquals(Expr pParam1, Expr pParam2, boolean signed) {
if (signed) {
return exprManager.mkExpr(Kind.BITVECTOR_SLE, pParam1, pParam2);
} else {
return exprManager.mkExpr(Kind.BITVECTOR_ULE, pParam1, pParam2);
}
}
@Override
protected Expr greaterThan(Expr pParam1, Expr pParam2, boolean signed) {
if (signed) {
return exprManager.mkExpr(Kind.BITVECTOR_SGT, pParam1, pParam2);
} else {
return exprManager.mkExpr(Kind.BITVECTOR_UGT, pParam1, pParam2);
}
}
@Override
protected Expr greaterOrEquals(Expr pParam1, Expr pParam2, boolean signed) {
if (signed) {
return exprManager.mkExpr(Kind.BITVECTOR_SGE, pParam1, pParam2);
} else {
return exprManager.mkExpr(Kind.BITVECTOR_UGE, pParam1, pParam2);
}
}
@Override
protected Expr makeBitvectorImpl(int pLength, Expr pParam1) {
Expr size = exprManager.mkConst(new IntToBitVector(pLength));
return exprManager.mkExpr(Kind.INT_TO_BITVECTOR, size, pParam1);
}
@Override
protected Expr toIntegerFormulaImpl(Expr pBv, boolean pSigned) {
Expr intExpr = exprManager.mkExpr(Kind.BITVECTOR_TO_NAT, pBv);
// CVC4 returns unsigned int by default
if (pSigned) {
// TODO check what is cheaper for the solver:
// checking the first BV-bit or computing max-int-value for the given size
final int size = Math.toIntExact(new BitVectorType(pBv.getType()).getSize());
final BigInteger modulo = BigInteger.ONE.shiftLeft(size);
final BigInteger maxInt = BigInteger.ONE.shiftLeft(size - 1).subtract(BigInteger.ONE);
final Expr moduloExpr = exprManager.mkConst(new Rational(modulo.toString()));
final Expr maxIntExpr = exprManager.mkConst(new Rational(maxInt.toString()));
intExpr =
exprManager.mkExpr(
Kind.ITE,
exprManager.mkExpr(Kind.GT, intExpr, maxIntExpr),
exprManager.mkExpr(Kind.MINUS, intExpr, moduloExpr),
intExpr);
}
return intExpr;
}
@Override
protected Expr distinctImpl(List<Expr> pParam) {
vectorExpr param = new vectorExpr();
pParam.forEach(param::add);
return exprManager.mkExpr(Kind.DISTINCT, param);
}
}
| 8,085 | 32.97479 | 93 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4BooleanFormulaManager.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.cvc4;
import com.google.common.collect.Iterables;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.Kind;
import edu.stanford.CVC4.Type;
import edu.stanford.CVC4.vectorExpr;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.Set;
import org.sosy_lab.java_smt.basicimpl.AbstractBooleanFormulaManager;
public class CVC4BooleanFormulaManager
extends AbstractBooleanFormulaManager<Expr, Type, ExprManager, Expr> {
private final Expr cvc4True;
private final Expr cvc4False;
private final ExprManager exprManager;
protected CVC4BooleanFormulaManager(CVC4FormulaCreator pCreator) {
super(pCreator);
exprManager = pCreator.getEnv();
cvc4True = exprManager.mkConst(true);
cvc4False = exprManager.mkConst(false);
}
@Override
protected Expr makeVariableImpl(String pVar) {
return formulaCreator.makeVariable(getFormulaCreator().getBoolType(), pVar);
}
@Override
protected Expr makeBooleanImpl(boolean pValue) {
return pValue ? cvc4True : cvc4False;
}
@Override
protected Expr not(Expr pParam1) {
if (isTrue(pParam1)) {
return cvc4False;
} else if (isFalse(pParam1)) {
return cvc4True;
} else if (pParam1.getKind() == Kind.NOT) {
return pParam1.getChild(0);
}
return exprManager.mkExpr(Kind.NOT, pParam1);
}
@Override
protected Expr and(Expr pParam1, Expr pParam2) {
if (isTrue(pParam1)) {
return pParam2;
} else if (isTrue(pParam2)) {
return pParam1;
} else if (isFalse(pParam1)) {
return cvc4False;
} else if (isFalse(pParam2)) {
return cvc4False;
} else if (pParam1 == pParam2) {
return pParam1;
}
return exprManager.mkExpr(Kind.AND, pParam1, pParam2);
}
@Override
protected Expr andImpl(Collection<Expr> pParams) {
// CVC4 does not do any simplifications,
// so we filter "true", short-circuit on "false", and filter out (simple) redundancies.
final Set<Expr> operands = new LinkedHashSet<>();
for (final Expr operand : pParams) {
if (isFalse(operand)) {
return cvc4False;
}
if (!isTrue(operand)) {
operands.add(operand);
}
}
switch (operands.size()) {
case 0:
return cvc4True;
case 1:
return Iterables.getOnlyElement(operands);
default:
vectorExpr vExpr = new vectorExpr();
for (Expr e : operands) {
vExpr.add(e);
}
return exprManager.mkExpr(Kind.AND, vExpr);
}
}
@Override
protected Expr or(Expr pParam1, Expr pParam2) {
if (isTrue(pParam1)) {
return cvc4True;
} else if (isTrue(pParam2)) {
return cvc4True;
} else if (isFalse(pParam1)) {
return pParam2;
} else if (isFalse(pParam2)) {
return pParam1;
} else if (pParam1 == pParam2) {
return pParam1;
}
return exprManager.mkExpr(Kind.OR, pParam1, pParam2);
}
@Override
protected Expr orImpl(Collection<Expr> pParams) {
// CVC4 does not do any simplifications,
// so we filter "true", short-circuit on "false", and filter out (simple) redundancies.
final Set<Expr> operands = new LinkedHashSet<>();
for (final Expr operand : pParams) {
if (isTrue(operand)) {
return cvc4True;
}
if (!isFalse(operand)) {
operands.add(operand);
}
}
switch (operands.size()) {
case 0:
return cvc4False;
case 1:
return Iterables.getOnlyElement(operands);
default:
vectorExpr vExpr = new vectorExpr();
for (Expr e : operands) {
vExpr.add(e);
}
return exprManager.mkExpr(Kind.OR, vExpr);
}
}
@Override
protected Expr xor(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.XOR, pParam1, pParam2);
}
@Override
protected Expr equivalence(Expr pBits1, Expr pBits2) {
return exprManager.mkExpr(Kind.EQUAL, pBits1, pBits2);
}
@Override
protected Expr implication(Expr bits1, Expr bits2) {
return exprManager.mkExpr(Kind.IMPLIES, bits1, bits2);
}
@Override
protected boolean isTrue(Expr pBits) {
return pBits.isConst() && pBits.getConstBoolean();
}
@Override
protected boolean isFalse(Expr pBits) {
return pBits.isConst() && !pBits.getConstBoolean();
}
@Override
protected Expr ifThenElse(Expr pCond, Expr pF1, Expr 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 exprManager.mkExpr(Kind.ITE, pCond, pF1, pF2);
}
}
| 5,041 | 26.254054 | 91 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4Evaluator.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.cvc4;
import com.google.common.base.Preconditions;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.SmtEngine;
import edu.stanford.CVC4.Type;
import org.sosy_lab.java_smt.basicimpl.AbstractEvaluator;
public class CVC4Evaluator extends AbstractEvaluator<Expr, Type, ExprManager> {
private final SmtEngine smtEngine;
private final CVC4TheoremProver prover;
CVC4Evaluator(CVC4TheoremProver pProver, CVC4FormulaCreator pCreator, SmtEngine pSmtEngine) {
super(pProver, pCreator);
smtEngine = pSmtEngine;
prover = pProver;
}
@Override
public Expr evalImpl(Expr f) {
Preconditions.checkState(!isClosed());
return getValue(f);
}
/** we need to convert the given expression into the current context. */
private Expr getValue(Expr f) {
return prover.exportExpr(smtEngine.getValue(prover.importExpr(f)));
}
}
| 1,171 | 28.3 | 95 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4FloatingPointFormulaManager.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.cvc4;
import com.google.common.collect.ImmutableList;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.FloatingPoint;
import edu.stanford.CVC4.FloatingPointConvertSort;
import edu.stanford.CVC4.FloatingPointSize;
import edu.stanford.CVC4.FloatingPointToFPFloatingPoint;
import edu.stanford.CVC4.FloatingPointToFPSignedBitVector;
import edu.stanford.CVC4.FloatingPointToFPUnsignedBitVector;
import edu.stanford.CVC4.FloatingPointToSBV;
import edu.stanford.CVC4.FloatingPointToUBV;
import edu.stanford.CVC4.Kind;
import edu.stanford.CVC4.Rational;
import edu.stanford.CVC4.RoundingMode;
import edu.stanford.CVC4.Type;
import java.math.BigDecimal;
import java.math.BigInteger;
import org.sosy_lab.java_smt.api.FloatingPointRoundingMode;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.FormulaType.BitvectorType;
import org.sosy_lab.java_smt.api.FormulaType.FloatingPointType;
import org.sosy_lab.java_smt.basicimpl.AbstractFloatingPointFormulaManager;
public class CVC4FloatingPointFormulaManager
extends AbstractFloatingPointFormulaManager<Expr, Type, ExprManager, Expr> {
private final ExprManager exprManager;
private final Expr roundingMode;
protected CVC4FloatingPointFormulaManager(
CVC4FormulaCreator pCreator, FloatingPointRoundingMode pFloatingPointRoundingMode) {
super(pCreator);
exprManager = pCreator.getEnv();
roundingMode = getRoundingModeImpl(pFloatingPointRoundingMode);
}
// TODO Is there a difference in `FloatingPointSize` and `FloatingPointType` in CVC4?
// They are both just pairs of `exponent size` and `significant size`.
private static FloatingPointSize getFPSize(FloatingPointType pType) {
long pExponentSize = pType.getExponentSize();
long pMantissaSize = pType.getMantissaSize();
return new FloatingPointSize(pExponentSize, pMantissaSize + 1); // plus sign bit
}
@Override
protected Expr getDefaultRoundingMode() {
return roundingMode;
}
@Override
protected Expr getRoundingModeImpl(FloatingPointRoundingMode pFloatingPointRoundingMode) {
switch (pFloatingPointRoundingMode) {
case NEAREST_TIES_TO_EVEN:
return exprManager.mkConst(RoundingMode.roundNearestTiesToEven);
case NEAREST_TIES_AWAY:
return exprManager.mkConst(RoundingMode.roundNearestTiesToAway);
case TOWARD_POSITIVE:
return exprManager.mkConst(RoundingMode.roundTowardPositive);
case TOWARD_NEGATIVE:
return exprManager.mkConst(RoundingMode.roundTowardNegative);
case TOWARD_ZERO:
return exprManager.mkConst(RoundingMode.roundTowardZero);
default:
throw new AssertionError("Unexpected branch");
}
}
@Override
protected Expr makeNumberImpl(double pN, FloatingPointType pType, Expr pRoundingMode) {
return makeNumberImpl(Double.toString(pN), pType, pRoundingMode);
}
@Override
protected Expr makeNumberAndRound(String pN, FloatingPointType pType, Expr pRoundingMode) {
try {
if (isNegativeZero(Double.valueOf(pN))) {
return negate(
exprManager.mkConst(
new FloatingPoint(
getFPSize(pType),
pRoundingMode.getConstRoundingMode(),
Rational.fromDecimal(pN))));
}
} catch (NumberFormatException e) {
// ignore and fallback to floating point from rational numbers
}
final Rational rat = toRational(pN);
final BigInteger upperBound =
getBiggestNumberBeforeInf(pType.getMantissaSize(), pType.getExponentSize());
if (rat.greater(Rational.fromDecimal(upperBound.negate().toString()))
&& rat.less(Rational.fromDecimal(upperBound.toString()))) {
return exprManager.mkConst(
new FloatingPoint(getFPSize(pType), pRoundingMode.getConstRoundingMode(), rat));
} else { // out of range
if (rat.greater(Rational.fromDecimal("0"))) {
return makePlusInfinityImpl(pType);
} else {
return makeMinusInfinityImpl(pType);
}
}
}
// TODO lookup why this number works: <code>2**(2**(exp-1)) - 2**(2**(exp-1)-2-mant)</code>
private static BigInteger getBiggestNumberBeforeInf(int mantissa, int exponent) {
int boundExponent = BigInteger.valueOf(2).pow(exponent - 1).intValueExact();
BigInteger upperBoundExponent = BigInteger.valueOf(2).pow(boundExponent);
int mantissaExponent = BigInteger.valueOf(2).pow(exponent - 1).intValueExact() - 2 - mantissa;
if (mantissaExponent >= 0) { // ignore negative mantissaExponent
upperBoundExponent = upperBoundExponent.subtract(BigInteger.valueOf(2).pow(mantissaExponent));
}
return upperBoundExponent;
}
/**
* Try to convert a String numeral into a Rational.
*
* <p>If we do not check all invalid formatted numbers in our own code, CVC4 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.fromDecimal(new BigDecimal(pN).toPlainString());
} catch (NumberFormatException e1) {
try {
// then try something like -123/456
@SuppressWarnings("unused") // check format before calling CVC4
org.sosy_lab.common.rationals.Rational unused =
org.sosy_lab.common.rationals.Rational.ofString(pN);
return new Rational(pN);
} catch (NumberFormatException e2) {
// we cannot handle the number
throw new NumberFormatException("invalid numeral: " + pN);
}
}
}
@Override
protected Expr makeVariableImpl(String varName, FloatingPointType pType) {
return formulaCreator.makeVariable(formulaCreator.getFloatingPointType(pType), varName);
}
@Override
protected Expr makePlusInfinityImpl(FloatingPointType pType) {
return exprManager.mkConst(FloatingPoint.makeInf(getFPSize(pType), /* sign */ false));
}
@Override
protected Expr makeMinusInfinityImpl(FloatingPointType pType) {
return exprManager.mkConst(FloatingPoint.makeInf(getFPSize(pType), /* sign */ true));
}
@Override
protected Expr makeNaNImpl(FloatingPointType pType) {
return exprManager.mkConst(FloatingPoint.makeNaN(getFPSize(pType)));
}
@Override
protected Expr castToImpl(
Expr pNumber, boolean pSigned, FormulaType<?> pTargetType, Expr pRoundingMode) {
if (pTargetType.isFloatingPointType()) {
FloatingPointType targetType = (FloatingPointType) pTargetType;
FloatingPointConvertSort fpConvertSort = new FloatingPointConvertSort(getFPSize(targetType));
Expr op = exprManager.mkConst(new FloatingPointToFPFloatingPoint(fpConvertSort));
return exprManager.mkExpr(op, pRoundingMode, pNumber);
} else if (pTargetType.isBitvectorType()) {
BitvectorType targetType = (BitvectorType) pTargetType;
Expr op =
pSigned
? exprManager.mkConst(new FloatingPointToSBV(targetType.getSize()))
: exprManager.mkConst(new FloatingPointToUBV(targetType.getSize()));
return exprManager.mkExpr(op, pRoundingMode, pNumber);
} else if (pTargetType.isRationalType()) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_TO_REAL, pNumber);
} else {
return genericCast(pNumber, pTargetType);
}
}
@Override
protected Expr castFromImpl(
Expr pNumber, boolean pSigned, FloatingPointType pTargetType, Expr pRoundingMode) {
FormulaType<?> formulaType = getFormulaCreator().getFormulaType(pNumber);
if (formulaType.isFloatingPointType()) {
return castToImpl(pNumber, pSigned, pTargetType, pRoundingMode);
} else if (formulaType.isBitvectorType()) {
long pExponentSize = pTargetType.getExponentSize();
long pMantissaSize = pTargetType.getMantissaSize();
FloatingPointSize fpSize = new FloatingPointSize(pExponentSize, pMantissaSize + 1);
FloatingPointConvertSort fpConvert = new FloatingPointConvertSort(fpSize);
final Expr op;
if (pSigned) {
op = exprManager.mkConst(new FloatingPointToFPSignedBitVector(fpConvert));
} else {
op = exprManager.mkConst(new FloatingPointToFPUnsignedBitVector(fpConvert));
}
return exprManager.mkExpr(op, pRoundingMode, pNumber);
} else {
return genericCast(pNumber, pTargetType);
}
}
private Expr genericCast(Expr pNumber, FormulaType<?> pTargetType) {
Type type = pNumber.getType();
FormulaType<?> argType = getFormulaCreator().getFormulaType(pNumber);
Expr castFuncDecl =
getFormulaCreator()
.declareUFImpl(
"__cast_" + argType + "_to_" + pTargetType,
toSolverType(pTargetType),
ImmutableList.of(type));
return exprManager.mkExpr(Kind.APPLY_UF, castFuncDecl, pNumber);
}
@Override
protected Expr negate(Expr pParam1) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_NEG, pParam1);
}
@Override
protected Expr abs(Expr pParam1) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_ABS, pParam1);
}
@Override
protected Expr max(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_MAX, pParam1, pParam2);
}
@Override
protected Expr min(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_MIN, pParam1, pParam2);
}
@Override
protected Expr sqrt(Expr pParam1, Expr pRoundingMode) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_SQRT, pRoundingMode, pParam1);
}
@Override
protected Expr add(Expr pParam1, Expr pParam2, Expr pRoundingMode) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_PLUS, pRoundingMode, pParam1, pParam2);
}
@Override
protected Expr subtract(Expr pParam1, Expr pParam2, Expr pRoundingMode) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_SUB, pRoundingMode, pParam1, pParam2);
}
@Override
protected Expr divide(Expr pParam1, Expr pParam2, Expr pRoundingMode) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_DIV, pRoundingMode, pParam1, pParam2);
}
@Override
protected Expr multiply(Expr pParam1, Expr pParam2, Expr pRoundingMode) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_MULT, pRoundingMode, pParam1, pParam2);
}
@Override
protected Expr assignment(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.EQUAL, pParam1, pParam2);
}
@Override
protected Expr equalWithFPSemantics(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_EQ, pParam1, pParam2);
}
@Override
protected Expr greaterThan(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_GT, pParam1, pParam2);
}
@Override
protected Expr greaterOrEquals(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_GEQ, pParam1, pParam2);
}
@Override
protected Expr lessThan(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_LT, pParam1, pParam2);
}
@Override
protected Expr lessOrEquals(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_LEQ, pParam1, pParam2);
}
@Override
protected Expr isNaN(Expr pParam1) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_ISNAN, pParam1);
}
@Override
protected Expr isInfinity(Expr pParam1) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_ISINF, pParam1);
}
@Override
protected Expr isZero(Expr pParam1) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_ISZ, pParam1);
}
@Override
protected Expr isSubnormal(Expr pParam1) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_ISSN, pParam1);
}
@Override
protected Expr isNormal(Expr pParam) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_ISN, pParam);
}
@Override
protected Expr isNegative(Expr pParam) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_ISNEG, pParam);
}
@Override
protected Expr fromIeeeBitvectorImpl(Expr pNumber, FloatingPointType pTargetType) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_FP, pNumber);
}
@Override
protected Expr toIeeeBitvectorImpl(Expr pNumber) {
// TODO possible work-around: use a tmp-variable "TMP" and add an
// additional constraint "pNumer == fromIeeeBitvectorImpl(TMP)" for it in all use-cases.
throw new UnsupportedOperationException("FP to IEEE-BV is not supported");
}
@Override
protected Expr round(Expr pFormula, FloatingPointRoundingMode pRoundingMode) {
return exprManager.mkExpr(Kind.FLOATINGPOINT_RTI, getRoundingModeImpl(pRoundingMode), pFormula);
}
}
| 12,843 | 34.677778 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4Formula.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.cvc4;
import com.google.errorprone.annotations.Immutable;
import edu.stanford.CVC4.Expr;
import org.sosy_lab.java_smt.api.ArrayFormula;
import org.sosy_lab.java_smt.api.BitvectorFormula;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.FloatingPointFormula;
import org.sosy_lab.java_smt.api.FloatingPointRoundingModeFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.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 CVC4Formula implements Formula {
@SuppressWarnings("Immutable")
private final Expr cvc4term;
CVC4Formula(Expr term) {
cvc4term = term;
}
@Override
public final String toString() {
return cvc4term.toString();
}
@Override
public final boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof CVC4Formula)) {
return false;
}
return cvc4term.equals(((CVC4Formula) o).cvc4term);
}
@Override
public final int hashCode() {
// termId works like a hashCode
return cvc4term.getId().intValue();
}
final Expr getTerm() {
return cvc4term;
}
@Immutable
@SuppressWarnings("ClassTypeParameterName")
static final class CVC4ArrayFormula<TI extends Formula, TE extends Formula> extends CVC4Formula
implements ArrayFormula<TI, TE> {
private final FormulaType<TI> indexType;
private final FormulaType<TE> elementType;
CVC4ArrayFormula(Expr 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 CVC4BitvectorFormula extends CVC4Formula implements BitvectorFormula {
CVC4BitvectorFormula(Expr pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC4FloatingPointFormula extends CVC4Formula implements FloatingPointFormula {
CVC4FloatingPointFormula(Expr pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC4FloatingPointRoundingModeFormula extends CVC4Formula
implements FloatingPointRoundingModeFormula {
CVC4FloatingPointRoundingModeFormula(Expr pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC4IntegerFormula extends CVC4Formula implements IntegerFormula {
CVC4IntegerFormula(Expr pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC4RationalFormula extends CVC4Formula implements RationalFormula {
CVC4RationalFormula(Expr pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC4BooleanFormula extends CVC4Formula implements BooleanFormula {
CVC4BooleanFormula(Expr pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC4StringFormula extends CVC4Formula implements StringFormula {
CVC4StringFormula(Expr pTerm) {
super(pTerm);
}
}
@Immutable
static final class CVC4RegexFormula extends CVC4Formula implements RegexFormula {
CVC4RegexFormula(Expr pTerm) {
super(pTerm);
}
}
}
| 3,676 | 25.078014 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4FormulaCreator.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.cvc4;
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.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import com.google.common.primitives.UnsignedInteger;
import com.google.common.primitives.UnsignedLong;
import edu.stanford.CVC4.ArrayType;
import edu.stanford.CVC4.BitVectorType;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.FloatingPoint;
import edu.stanford.CVC4.FloatingPointSize;
import edu.stanford.CVC4.FunctionType;
import edu.stanford.CVC4.Integer;
import edu.stanford.CVC4.Kind;
import edu.stanford.CVC4.Rational;
import edu.stanford.CVC4.Type;
import edu.stanford.CVC4.vectorExpr;
import edu.stanford.CVC4.vectorType;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.sosy_lab.java_smt.api.ArrayFormula;
import org.sosy_lab.java_smt.api.BitvectorFormula;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.FloatingPointFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.FormulaType.ArrayFormulaType;
import org.sosy_lab.java_smt.api.FormulaType.FloatingPointType;
import org.sosy_lab.java_smt.api.FunctionDeclarationKind;
import org.sosy_lab.java_smt.api.QuantifiedFormulaManager.Quantifier;
import org.sosy_lab.java_smt.api.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.cvc4.CVC4Formula.CVC4ArrayFormula;
import org.sosy_lab.java_smt.solvers.cvc4.CVC4Formula.CVC4BitvectorFormula;
import org.sosy_lab.java_smt.solvers.cvc4.CVC4Formula.CVC4BooleanFormula;
import org.sosy_lab.java_smt.solvers.cvc4.CVC4Formula.CVC4FloatingPointFormula;
import org.sosy_lab.java_smt.solvers.cvc4.CVC4Formula.CVC4FloatingPointRoundingModeFormula;
import org.sosy_lab.java_smt.solvers.cvc4.CVC4Formula.CVC4IntegerFormula;
import org.sosy_lab.java_smt.solvers.cvc4.CVC4Formula.CVC4RationalFormula;
import org.sosy_lab.java_smt.solvers.cvc4.CVC4Formula.CVC4RegexFormula;
import org.sosy_lab.java_smt.solvers.cvc4.CVC4Formula.CVC4StringFormula;
public class CVC4FormulaCreator extends FormulaCreator<Expr, Type, ExprManager, Expr> {
private static final Pattern FLOATING_POINT_PATTERN =
Pattern.compile("^\\(fp #b(?<sign>\\d) #b(?<exp>\\d+) #b(?<mant>\\d+)$");
private final Map<String, Expr> variablesCache = new HashMap<>();
private final Map<String, Expr> functionsCache = new HashMap<>();
private final ExprManager exprManager;
protected CVC4FormulaCreator(ExprManager pExprManager) {
super(
pExprManager,
pExprManager.booleanType(),
pExprManager.integerType(),
pExprManager.realType(),
pExprManager.stringType(),
pExprManager.regExpType());
exprManager = pExprManager;
}
@Override
public Expr makeVariable(Type type, String name) {
Expr exp = variablesCache.computeIfAbsent(name, n -> exprManager.mkVar(name, type));
Preconditions.checkArgument(
type.equals(exp.getType()),
"symbol name already in use for different type %s",
exp.getType());
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 Expr makeBoundCopy(Expr var) {
Type type = var.getType();
String name = getName(var);
Expr boundCopy = exprManager.mkBoundVar(name, type);
return boundCopy;
}
@Override
public Type getBitvectorType(int pBitwidth) {
return exprManager.mkBitVectorType(pBitwidth);
}
@Override
public Type getFloatingPointType(FloatingPointType pType) {
return exprManager.mkFloatingPointType(
pType.getExponentSize(), pType.getMantissaSize() + 1); // plus sign bit
}
@Override
public Type getArrayType(Type pIndexType, Type pElementType) {
return exprManager.mkArrayType(pIndexType, pElementType);
}
@Override
public Expr extractInfo(Formula pT) {
return CVC4FormulaManager.getCVC4Expr(pT);
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TD extends Formula, TR extends Formula> FormulaType<TR> getArrayFormulaElementType(
ArrayFormula<TD, TR> pArray) {
return ((CVC4ArrayFormula<TD, TR>) pArray).getElementType();
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TD extends Formula, TR extends Formula> FormulaType<TD> getArrayFormulaIndexType(
ArrayFormula<TD, TR> pArray) {
return ((CVC4ArrayFormula<TD, TR>) pArray).getIndexType();
}
@SuppressWarnings("unchecked")
@Override
public <T extends Formula> FormulaType<T> getFormulaType(T pFormula) {
Type t = extractInfo(pFormula).getType();
if (pFormula instanceof BitvectorFormula) {
checkArgument(t.isBitVector(), "BitvectorFormula with actual type %s: %s", t, pFormula);
return (FormulaType<T>) getFormulaType(extractInfo(pFormula));
} else if (pFormula instanceof FloatingPointFormula) {
checkArgument(
t.isFloatingPoint(), "FloatingPointFormula with actual type %s: %s", t, pFormula);
edu.stanford.CVC4.FloatingPointType fpType = new edu.stanford.CVC4.FloatingPointType(t);
return (FormulaType<T>)
FormulaType.getFloatingPointType(
(int) fpType.getExponentSize(),
(int) fpType.getSignificandSize() - 1); // without sign bit
} else if (pFormula instanceof ArrayFormula<?, ?>) {
FormulaType<T> arrayIndexType = getArrayFormulaIndexType((ArrayFormula<T, T>) pFormula);
FormulaType<T> arrayElementType = getArrayFormulaElementType((ArrayFormula<T, T>) pFormula);
return (FormulaType<T>) FormulaType.getArrayType(arrayIndexType, arrayElementType);
}
return super.getFormulaType(pFormula);
}
@Override
public FormulaType<?> getFormulaType(Expr pFormula) {
return getFormulaTypeFromTermType(pFormula.getType());
}
private FormulaType<?> getFormulaTypeFromTermType(Type t) {
if (t.isBoolean()) {
return FormulaType.BooleanType;
} else if (t.isInteger()) {
return FormulaType.IntegerType;
} else if (t.isBitVector()) {
// apparently, we can get a t instanceof Type here for that t instanceof BitVectorType does
// not hold, hence we use the new BitVectorType(t) here as a workaround:
return FormulaType.getBitvectorTypeWithSize((int) new BitVectorType(t).getSize());
} else if (t.isFloatingPoint()) {
edu.stanford.CVC4.FloatingPointType fpType = new edu.stanford.CVC4.FloatingPointType(t);
return FormulaType.getFloatingPointType(
(int) fpType.getExponentSize(),
(int) fpType.getSignificandSize() - 1); // without sign bit
} else if (t.isRoundingMode()) {
return FormulaType.FloatingPointRoundingModeType;
} else if (t.isReal()) {
// The theory REAL in CVC4 is the theory of (infinite precision!) real numbers.
// As such, the theory RATIONAL is contained in REAL. TODO: find a better solution.
return FormulaType.RationalType;
} else if (t.isArray()) {
ArrayType arrayType = new ArrayType(t); // instead of casting, create a new type.
FormulaType<?> indexType = getFormulaTypeFromTermType(arrayType.getIndexType());
FormulaType<?> elementType = getFormulaTypeFromTermType(arrayType.getConstituentType());
return FormulaType.getArrayType(indexType, elementType);
} else if (t.isString()) {
return FormulaType.StringType;
} else if (t.isRegExp()) {
return FormulaType.RegexType;
} else {
throw new AssertionError(
String.format("Unhandled type '%s' with base type '%s'.", t, t.getBaseType()));
}
}
@SuppressWarnings("unchecked")
@Override
public <T extends Formula> T encapsulate(FormulaType<T> pType, Expr pTerm) {
assert pType.equals(getFormulaType(pTerm))
|| (pType.equals(FormulaType.RationalType)
&& getFormulaType(pTerm).equals(FormulaType.IntegerType))
: String.format(
"Trying to encapsulate formula %s of type %s as %s",
pTerm, getFormulaType(pTerm), pType);
if (pType.isBooleanType()) {
return (T) new CVC4BooleanFormula(pTerm);
} else if (pType.isIntegerType()) {
return (T) new CVC4IntegerFormula(pTerm);
} else if (pType.isRationalType()) {
return (T) new CVC4RationalFormula(pTerm);
} else if (pType.isArrayType()) {
ArrayFormulaType<?, ?> arrFt = (ArrayFormulaType<?, ?>) pType;
return (T) new CVC4ArrayFormula<>(pTerm, arrFt.getIndexType(), arrFt.getElementType());
} else if (pType.isBitvectorType()) {
return (T) new CVC4BitvectorFormula(pTerm);
} else if (pType.isFloatingPointType()) {
return (T) new CVC4FloatingPointFormula(pTerm);
} else if (pType.isFloatingPointRoundingModeType()) {
return (T) new CVC4FloatingPointRoundingModeFormula(pTerm);
} else if (pType.isStringType()) {
return (T) new CVC4StringFormula(pTerm);
} else if (pType.isRegexType()) {
return (T) new CVC4RegexFormula(pTerm);
}
throw new IllegalArgumentException("Cannot create formulas of type " + pType + " in CVC4");
}
private Formula encapsulate(Expr pTerm) {
return encapsulate(getFormulaType(pTerm), pTerm);
}
@Override
public BooleanFormula encapsulateBoolean(Expr pTerm) {
assert getFormulaType(pTerm).isBooleanType()
: String.format(
"%s is not boolean, but %s (%s)", pTerm, pTerm.getType(), getFormulaType(pTerm));
return new CVC4BooleanFormula(pTerm);
}
@Override
public BitvectorFormula encapsulateBitvector(Expr pTerm) {
assert getFormulaType(pTerm).isBitvectorType()
: String.format("%s is no BV, but %s (%s)", pTerm, pTerm.getType(), getFormulaType(pTerm));
return new CVC4BitvectorFormula(pTerm);
}
@Override
protected FloatingPointFormula encapsulateFloatingPoint(Expr pTerm) {
assert getFormulaType(pTerm).isFloatingPointType()
: String.format("%s is no FP, but %s (%s)", pTerm, pTerm.getType(), getFormulaType(pTerm));
return new CVC4FloatingPointFormula(pTerm);
}
@Override
@SuppressWarnings("MethodTypeParameterName")
protected <TI extends Formula, TE extends Formula> ArrayFormula<TI, TE> encapsulateArray(
Expr 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.getType(), getFormulaType(pTerm));
return new CVC4ArrayFormula<>(pTerm, pIndexType, pElementType);
}
@Override
protected StringFormula encapsulateString(Expr pTerm) {
assert getFormulaType(pTerm).isStringType()
: String.format(
"%s is no String, but %s (%s)", pTerm, pTerm.getType(), getFormulaType(pTerm));
return new CVC4StringFormula(pTerm);
}
@Override
protected RegexFormula encapsulateRegex(Expr pTerm) {
assert getFormulaType(pTerm).isRegexType();
return new CVC4RegexFormula(pTerm);
}
private static String getName(Expr e) {
checkState(!e.isNull());
if (!e.isConst() && !e.isVariable()) {
e = e.getOperator();
}
return dequote(e.toString());
}
@Override
public <R> R visit(FormulaVisitor<R> visitor, Formula formula, final Expr f) {
checkState(!f.isNull());
Type type = f.getType();
if (f.isConst()) {
if (type.isBoolean()) {
return visitor.visitConstant(formula, f.getConstBoolean());
} else if (type.isInteger()) {
Rational rationalValue = f.getConstRational();
Preconditions.checkState("1".equals(rationalValue.getDenominator().toString()));
return visitor.visitConstant(
formula, new BigInteger(rationalValue.getNumerator().toString()));
} else if (type.isReal()) {
Rational rationalValue = f.getConstRational();
return visitor.visitConstant(
formula,
org.sosy_lab.common.rationals.Rational.of(
new BigInteger(rationalValue.getNumerator().toString()),
new BigInteger(rationalValue.getDenominator().toString())));
} else if (type.isBitVector()) {
return visitor.visitConstant(
formula, new BigInteger(f.getConstBitVector().getValue().toString(10)));
} else if (type.isFloatingPoint()) {
// TODO is this correct?
return visitor.visitConstant(formula, f.getConstFloatingPoint());
} else if (type.isRoundingMode()) {
// TODO is this correct?
return visitor.visitConstant(formula, f.getConstRoundingMode());
} else if (type.isString()) {
return visitor.visitConstant(formula, f.getConstString());
} else {
throw new UnsupportedOperationException("Unhandled constant " + f + " with type " + type);
}
} else if (f.getKind() == Kind.BOUND_VARIABLE) {
// BOUND vars are used for all vars that are bound to a quantifier in CVC4.
// We resubstitute them back to the original free.
// CVC4 doesn't give you the de-brujin index
Expr originalVar = variablesCache.get(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;
Expr body = f.getChildren().get(1);
List<Formula> freeVars = new ArrayList<>();
for (Expr boundVar : f.getChild(0)) { // unpack grand-children of f.
String name = getName(boundVar);
Expr 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.isVariable()) {
assert f.getKind() != Kind.BOUND_VARIABLE;
return visitor.visitFreeVariable(formula, getName(f));
} else {
// 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()!
List<Formula> args = ImmutableList.copyOf(Iterables.transform(f, this::encapsulate));
List<FormulaType<?>> argsTypes = new ArrayList<>();
Expr operator = normalize(f.getOperator());
if (operator.getType().isFunction()) {
vectorType argTypes = new FunctionType(operator.getType()).getArgTypes();
for (int i = 0; i < argTypes.size(); i++) {
argsTypes.add(getFormulaTypeFromTermType(argTypes.get(i)));
}
} else {
for (Expr arg : f) {
argsTypes.add(getFormulaType(arg));
}
}
checkState(args.size() == argsTypes.size());
// 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.
return visitor.visitFunction(
formula,
args,
FunctionDeclarationImpl.of(
getName(f), getDeclarationKind(f), argsTypes, getFormulaType(f), operator));
}
}
/** CVC4 returns new objects when querying operators for UFs. The new operator */
private Expr normalize(Expr operator) {
Expr function = functionsCache.get(getName(operator));
if (function != null) {
checkState(
function.getId().equals(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 CVC4 sources for description of the different CVC4 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.PLUS, FunctionDeclarationKind.ADD)
.put(Kind.MULT, FunctionDeclarationKind.MUL)
.put(Kind.MINUS, FunctionDeclarationKind.SUB)
.put(Kind.INTS_DIVISION, FunctionDeclarationKind.DIV)
.put(Kind.INTS_MODULUS, FunctionDeclarationKind.MODULO)
.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_PLUS, 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)
.put(Kind.BITVECTOR_SHL, FunctionDeclarationKind.BV_SHL)
.put(Kind.BITVECTOR_ASHR, FunctionDeclarationKind.BV_ASHR)
.put(Kind.BITVECTOR_LSHR, FunctionDeclarationKind.BV_LSHR)
// 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)
// Floating-point theory
.put(Kind.TO_INTEGER, FunctionDeclarationKind.FLOOR)
.put(Kind.FLOATINGPOINT_TO_SBV, FunctionDeclarationKind.FP_CASTTO_SBV)
.put(Kind.FLOATINGPOINT_TO_UBV, FunctionDeclarationKind.FP_CASTTO_UBV)
.put(Kind.FLOATINGPOINT_TO_FP_FLOATINGPOINT, FunctionDeclarationKind.FP_CASTTO_FP)
.put(Kind.FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR, FunctionDeclarationKind.BV_SCASTTO_FP)
.put(Kind.FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR, FunctionDeclarationKind.BV_UCASTTO_FP)
.put(Kind.FLOATINGPOINT_ISNAN, FunctionDeclarationKind.FP_IS_NAN)
.put(Kind.FLOATINGPOINT_ISNEG, FunctionDeclarationKind.FP_IS_NEGATIVE)
.put(Kind.FLOATINGPOINT_ISINF, FunctionDeclarationKind.FP_IS_INF)
.put(Kind.FLOATINGPOINT_ISN, FunctionDeclarationKind.FP_IS_NORMAL)
.put(Kind.FLOATINGPOINT_ISSN, FunctionDeclarationKind.FP_IS_SUBNORMAL)
.put(Kind.FLOATINGPOINT_ISZ, 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_NEG, FunctionDeclarationKind.FP_NEG)
.put(Kind.FLOATINGPOINT_PLUS, 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_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_IEEE_BITVECTOR, FunctionDeclarationKind.FP_AS_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_STRCTN, FunctionDeclarationKind.STR_CONTAINS)
.put(Kind.STRING_SUBSTR, FunctionDeclarationKind.STR_SUBSTRING)
.put(Kind.STRING_STRREPL, FunctionDeclarationKind.STR_REPLACE)
.put(Kind.STRING_STRREPLALL, FunctionDeclarationKind.STR_REPLACE_ALL)
.put(Kind.STRING_CHARAT, FunctionDeclarationKind.STR_CHAR_AT)
.put(Kind.STRING_LENGTH, FunctionDeclarationKind.STR_LENGTH)
.put(Kind.STRING_STRIDOF, 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_STOI, FunctionDeclarationKind.STR_TO_INT)
.put(Kind.STRING_ITOS, FunctionDeclarationKind.INT_TO_STR)
.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)
.buildOrThrow();
private FunctionDeclarationKind getDeclarationKind(Expr f) {
Kind kind = f.getKind();
// special case: IFF for Boolean, EQ for all other types
if (kind == Kind.EQUAL && Iterables.all(f, child -> child.getType().isBoolean())) {
return FunctionDeclarationKind.IFF;
}
return KIND_MAPPING.getOrDefault(kind, FunctionDeclarationKind.OTHER);
}
@Override
protected Expr getBooleanVarDeclarationImpl(Expr pTFormulaInfo) {
Kind kind = pTFormulaInfo.getKind();
assert kind == Kind.APPLY_UF || kind == Kind.VARIABLE : pTFormulaInfo.getKind();
if (kind == Kind.APPLY_UF) {
return pTFormulaInfo.getOperator();
} else {
return pTFormulaInfo;
}
}
@Override
public Expr callFunctionImpl(Expr pDeclaration, List<Expr> pArgs) {
if (pArgs.isEmpty()) {
return exprManager.mkExpr(pDeclaration);
} else {
vectorExpr args = new vectorExpr();
for (Expr expr : pArgs) {
args.add(expr);
}
return exprManager.mkExpr(pDeclaration, args);
}
}
@Override
public Expr declareUFImpl(String pName, Type pReturnType, List<Type> pArgTypes) {
Expr exp = functionsCache.get(pName);
if (exp == null) {
vectorType args = new vectorType();
for (Type t : pArgTypes) {
args.add(t);
}
exp = exprManager.mkVar(pName, exprManager.mkFunctionType(args, pReturnType));
functionsCache.put(pName, exp);
}
return exp;
}
@Override
public Object convertValue(Expr expForType, Expr value) {
final Type type = expForType.getType();
final Type valueType = value.getType();
if (value.getKind() == Kind.BOUND_VARIABLE) {
// CVC4 does not allow model values for bound vars
return value.toString();
} else if (valueType.isBoolean()) {
return value.getConstBoolean();
} else if (valueType.isInteger() && type.isInteger()) {
return new BigInteger(value.getConstRational().toString());
} else if (valueType.isReal() && type.isReal()) {
Rational rat = value.getConstRational();
org.sosy_lab.common.rationals.Rational ratValue =
org.sosy_lab.common.rationals.Rational.of(
new BigInteger(rat.getNumerator().toString()),
new BigInteger(rat.getDenominator().toString()));
return ratValue.isIntegral() ? ratValue.getNum() : ratValue;
} else if (valueType.isBitVector()) {
Integer bv = value.getConstBitVector().getValue();
if (bv.fitsSignedLong()) {
return BigInteger.valueOf(bv.getUnsignedLong());
} else {
return value.toString(); // default
}
} else if (valueType.isFloatingPoint()) {
return parseFloatingPoint(value);
} else if (valueType.isString()) {
return value.getConstString().toString();
} else {
// String serialization for unknown terms.
return value.toString();
}
}
private Object parseFloatingPoint(Expr fpExpr) {
Matcher matcher = FLOATING_POINT_PATTERN.matcher(fpExpr.toString());
if (!matcher.matches()) {
throw new NumberFormatException("Unknown floating-point format: " + fpExpr);
}
FloatingPoint fp = fpExpr.getConstFloatingPoint();
FloatingPointSize fpType = fp.getT();
long expWidth = fpType.exponentWidth();
long mantWidth = fpType.significandWidth() - 1; // without sign bit
assert matcher.group("sign").length() == 1;
assert matcher.group("exp").length() == expWidth;
assert matcher.group("mant").length() == mantWidth;
String str = matcher.group("sign") + matcher.group("exp") + matcher.group("mant");
if (expWidth == 11 && mantWidth == 52) {
return Double.longBitsToDouble(UnsignedLong.valueOf(str, 2).longValue());
} else if (expWidth == 8 && mantWidth == 23) {
return Float.intBitsToFloat(UnsignedInteger.valueOf(str, 2).intValue());
}
// TODO to be fully correct, we would need to interpret this string
return fpExpr.toString();
}
}
| 28,306 | 43.860539 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4FormulaManager.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.cvc4;
import com.google.common.base.Joiner;
import com.google.common.collect.Iterables;
import de.uni_freiburg.informatik.ultimate.logic.PrintTerm;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.Type;
import java.io.IOException;
import java.io.OutputStream;
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 CVC4FormulaManager extends AbstractFormulaManager<Expr, Type, ExprManager, Expr> {
private final CVC4FormulaCreator creator;
@SuppressWarnings("checkstyle:parameternumber")
CVC4FormulaManager(
CVC4FormulaCreator pFormulaCreator,
CVC4UFManager pFfmgr,
CVC4BooleanFormulaManager pBfmgr,
CVC4IntegerFormulaManager pIfmgr,
CVC4RationalFormulaManager pRfmgr,
CVC4BitvectorFormulaManager pBvfmgr,
CVC4FloatingPointFormulaManager pFpfmgr,
CVC4QuantifiedFormulaManager pQfmgr,
CVC4ArrayFormulaManager pAfmgr,
CVC4SLFormulaManager pSLfmgr,
CVC4StringFormulaManager pStrmgr) {
super(
pFormulaCreator,
pFfmgr,
pBfmgr,
pIfmgr,
pRfmgr,
pBvfmgr,
pFpfmgr,
pQfmgr,
pAfmgr,
pSLfmgr,
pStrmgr,
null);
creator = pFormulaCreator;
}
static Expr getCVC4Expr(Formula pT) {
if (pT instanceof CVC4Formula) {
return ((CVC4Formula) 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(Expr 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, Expr> allVars = new LinkedHashMap<>();
creator.extractVariablesAndUFs(f, true, allVars::put);
// print all symbols
for (Map.Entry<String, Expr> entry : allVars.entrySet()) {
String name = entry.getKey();
Expr 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<Type> childrenTypes = Iterables.transform(var, Expr::getType);
out.append(Joiner.on(" ").join(childrenTypes));
// and return type
out.append(") ").append(var.getType().toString()).append(")\n");
}
// now add the final assert
out.append("(assert ");
// f.toString() does expand all nested sub-expressions and causes exponential overhead.
// f.toStream() uses LET-expressions and is exactly what we want.
try (OutputStream stream =
new OutputStream() {
@Override
public void write(int chr) throws IOException {
out.append((char) chr);
}
}) {
f.toStream(stream);
}
out.append(')');
}
};
}
}
| 3,882 | 30.569106 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4IntegerFormulaManager.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.cvc4;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.Kind;
import edu.stanford.CVC4.Type;
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 CVC4IntegerFormulaManager
extends CVC4NumeralFormulaManager<IntegerFormula, IntegerFormula>
implements IntegerFormulaManager {
CVC4IntegerFormulaManager(CVC4FormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
}
@Override
protected Type getNumeralType() {
return getFormulaCreator().getIntegerType();
}
@Override
protected Expr makeNumberImpl(double pNumber) {
return makeNumberImpl((long) pNumber);
}
@Override
protected Expr makeNumberImpl(BigDecimal pNumber) {
return decimalAsInteger(pNumber);
}
@Override
public Expr divide(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.INTS_DIVISION, pParam1, pParam2);
}
@Override
protected Expr modularCongruence(Expr pNumber1, Expr pNumber2, long pModulo) {
return modularCongruence(pNumber1, pNumber2, BigInteger.valueOf(pModulo));
}
@Override
protected Expr modularCongruence(Expr pNumber1, Expr pNumber2, BigInteger pModulo) {
// ((_ divisible n) x) <==> (= x (* n (div x n)))
if (BigInteger.ZERO.compareTo(pModulo) < 0) {
Expr n = makeNumberImpl(pModulo);
Expr x = subtract(pNumber1, pNumber2);
return exprManager.mkExpr(
Kind.EQUAL,
x,
exprManager.mkExpr(Kind.MULT, n, exprManager.mkExpr(Kind.INTS_DIVISION, x, n)));
}
return exprManager.mkConst(true);
}
@Override
protected Expr makeNumberImpl(BigInteger pI) {
return makeNumberImpl(pI.toString());
}
@Override
protected Expr makeNumberImpl(String pI) {
if (!INTEGER_NUMBER.matcher(pI).matches()) {
throw new NumberFormatException("number is not an integer value: " + pI);
}
return super.makeNumberImpl(pI);
}
@Override
protected Expr makeVariableImpl(String pI) {
return formulaCreator.makeVariable(getFormulaCreator().getIntegerType(), pI);
}
}
| 2,479 | 28.52381 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4Model.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.cvc4;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.Kind;
import edu.stanford.CVC4.SmtEngine;
import edu.stanford.CVC4.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.Formula;
import org.sosy_lab.java_smt.basicimpl.AbstractModel;
public class CVC4Model extends AbstractModel<Expr, Type, ExprManager> {
private final ImmutableList<ValueAssignment> model;
private final SmtEngine smtEngine;
private final ImmutableList<Expr> assertedExpressions;
private final CVC4TheoremProver prover;
CVC4Model(
CVC4TheoremProver pProver,
CVC4FormulaCreator pCreator,
SmtEngine pSmtEngine,
Collection<Expr> pAssertedExpressions) {
super(pProver, pCreator);
smtEngine = pSmtEngine;
prover = pProver;
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 Expr evalImpl(Expr f) {
// This method looks like a violation of the constraint above: the SMT engine can be changed
// before querying this method. However, the prover guarantees to close the model before this
// can happen.
Preconditions.checkState(!isClosed());
return getValue(f);
}
/** we need to convert the given expression into the current context. */
private Expr getValue(Expr f) {
return prover.exportExpr(smtEngine.getValue(prover.importExpr(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 (Expr 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, Expr expr) {
if (expr.isConst() || expr.isNull()) {
// We don't care about consts.
return;
} else if (expr.isVariable() && expr.getKind() == Kind.BOUND_VARIABLE) {
// We don't care about bound vars (not in a UF), as they don't return a value.
return;
} else if (expr.isVariable() || expr.getOperator().getType().isFunction()) {
// This includes free vars and UFs, as well as bound vars in UFs !
builder.add(getAssignment(expr));
} else if (expr.getKind() == Kind.FORALL || expr.getKind() == Kind.EXISTS) {
// Body of the quantifier, with bound vars!
Expr body = expr.getChildren().get(1);
recursiveAssignmentFinder(builder, body);
} else {
// Only nested terms (AND, OR, ...) are left
for (Expr child : expr) {
recursiveAssignmentFinder(builder, child);
}
}
}
private ValueAssignment getAssignment(Expr pKeyTerm) {
List<Object> argumentInterpretation = new ArrayList<>();
for (Expr param : pKeyTerm) {
argumentInterpretation.add(evaluateImpl(param));
}
Expr name = pKeyTerm.hasOperator() ? pKeyTerm.getOperator() : pKeyTerm; // extract UF name
String nameStr = name.toString();
if (nameStr.startsWith("|") && nameStr.endsWith("|")) {
nameStr = nameStr.substring(1, nameStr.length() - 1);
}
Expr valueTerm = getValue(pKeyTerm);
Formula keyFormula = creator.encapsulateWithTypeOf(pKeyTerm);
Formula valueFormula = creator.encapsulateWithTypeOf(valueTerm);
BooleanFormula equation =
creator.encapsulateBoolean(creator.getEnv().mkExpr(Kind.EQUAL, pKeyTerm, valueTerm));
Object value = creator.convertValue(pKeyTerm, valueTerm);
return new ValueAssignment(
keyFormula, valueFormula, equation, nameStr, value, argumentInterpretation);
}
@Override
public ImmutableList<ValueAssignment> asList() {
return model;
}
}
| 4,808 | 38.097561 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4NativeAPITest.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.cvc4;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertThrows;
import edu.stanford.CVC4.ArrayType;
import edu.stanford.CVC4.BitVector;
import edu.stanford.CVC4.BitVectorType;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.FloatingPoint;
import edu.stanford.CVC4.FloatingPointSize;
import edu.stanford.CVC4.Kind;
import edu.stanford.CVC4.Rational;
import edu.stanford.CVC4.Result;
import edu.stanford.CVC4.Result.Sat;
import edu.stanford.CVC4.RoundingMode;
import edu.stanford.CVC4.SExpr;
import edu.stanford.CVC4.SmtEngine;
import edu.stanford.CVC4.SortType;
import edu.stanford.CVC4.Type;
import edu.stanford.CVC4.UnsatCore;
import edu.stanford.CVC4.vectorExpr;
import java.io.FileNotFoundException;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
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;
/*
* Please note that CVC4 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, CVC4 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 CVC4NativeAPITest {
private static final String INVALID_GETVALUE_STRING =
"Cannot get-value unless immediately preceded by SAT/NOT_ENTAILED or UNKNOWN response.";
private static final String INVALID_MODEL_STRING =
"Cannot get model unless immediately preceded by SAT/NOT_ENTAILED or UNKNOWN response.";
private Expr x;
private Expr array;
private Expr aAtxEq0;
private Expr aAtxEq1;
@BeforeClass
public static void loadCVC4() {
try {
NativeLibraries.loadLibrary("cvc4jni");
} catch (UnsatisfiedLinkError e) {
throw new AssumptionViolatedException("CVC4 is not available", e);
}
}
private ExprManager exprMgr;
private SmtEngine smtEngine;
@Before
public void createEnvironment() {
exprMgr = new ExprManager();
smtEngine = new SmtEngine(exprMgr);
// Set the logic
smtEngine.setLogic("ALL");
// options
smtEngine.setOption("produce-models", new SExpr(true));
smtEngine.setOption("finite-model-find", new SExpr(true));
smtEngine.setOption("sets-ext", new SExpr(true));
smtEngine.setOption("output-language", new SExpr("smt2"));
}
@After
public void freeEnvironment() {
smtEngine.delete();
exprMgr.delete();
}
@Test
public void checkSimpleUnsat() {
smtEngine.assertFormula(exprMgr.mkConst(false));
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
}
@Test
public void checkSimpleSat() {
smtEngine.assertFormula(exprMgr.mkConst(true));
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
@Test
public void checkSimpleEqualitySat() {
Expr one = exprMgr.mkConst(new Rational(1));
Expr assertion = exprMgr.mkExpr(Kind.EQUAL, one, one);
smtEngine.assertFormula(assertion);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
@Test
public void checkSimpleEqualityUnsat() {
Expr zero = exprMgr.mkConst(new Rational(0));
Expr one = exprMgr.mkConst(new Rational(1));
Expr assertion = exprMgr.mkExpr(Kind.EQUAL, zero, one);
smtEngine.assertFormula(assertion);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
}
@Test
public void checkSimpleInequalityUnsat() {
Expr one = exprMgr.mkConst(new Rational(1));
Expr assertion = exprMgr.mkExpr(Kind.NOT, exprMgr.mkExpr(Kind.EQUAL, one, one));
smtEngine.assertFormula(assertion);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
}
@Test
public void checkSimpleInequalitySat() {
Expr zero = exprMgr.mkConst(new Rational(0));
Expr one = exprMgr.mkConst(new Rational(1));
Expr assertion = exprMgr.mkExpr(Kind.NOT, exprMgr.mkExpr(Kind.EQUAL, zero, one));
smtEngine.assertFormula(assertion);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
@Test
public void checkSimpleLIAEqualitySat() {
Expr one = exprMgr.mkConst(new Rational(1));
Expr two = exprMgr.mkConst(new Rational(2));
Expr assertion = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.PLUS, one, one), two);
smtEngine.assertFormula(assertion);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
@Test
public void checkSimpleLIAEqualityUnsat() {
Expr one = exprMgr.mkConst(new Rational(1));
Expr assertion = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.PLUS, one, one), one);
smtEngine.assertFormula(assertion);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
}
@Test
public void checkSimpleLIASat() {
// x + y = 4 AND x * y = 4
Expr four = exprMgr.mkConst(new Rational(4));
Expr varX = exprMgr.mkVar("x", exprMgr.integerType());
Expr varY = exprMgr.mkVar("y", exprMgr.integerType());
Expr assertion1 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.MULT, varX, varY), four);
Expr assertion2 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.PLUS, varX, varY), four);
smtEngine.assertFormula(assertion1);
smtEngine.assertFormula(assertion2);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
assertThat(getInt(varX) + getInt(varY)).isEqualTo(4);
assertThat(getInt(varX) * getInt(varY)).isEqualTo(4);
}
/** Helper to get to int values faster. */
private int getInt(Expr cvc4Expr) {
String string = smtEngine.getValue(cvc4Expr).toString();
return Integer.parseInt(string);
}
@Test
public void checkSimpleLIAUnsat() {
// x + y = 1 AND x * y = 1
Expr one = exprMgr.mkConst(new Rational(1));
Expr varX = exprMgr.mkVar("x", exprMgr.integerType());
Expr varY = exprMgr.mkVar("y", exprMgr.integerType());
Expr assertion1 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.MULT, varX, varY), one);
Expr assertion2 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.PLUS, varX, varY), one);
smtEngine.assertFormula(assertion1);
smtEngine.assertFormula(assertion2);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
}
@Test
public void checkLIAModel() {
// 1 + 2 = var
// it follows that var = 3
Expr one = exprMgr.mkConst(new Rational(1));
Expr two = exprMgr.mkConst(new Rational(2));
Expr var = exprMgr.mkVar(exprMgr.integerType());
Expr assertion = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.PLUS, one, two), var);
Result result = smtEngine.checkSat(assertion);
assertThat(result.isSat()).isEqualTo(Sat.SAT);
Expr assertionValue = smtEngine.getValue(assertion);
assertThat(assertionValue.toString()).isEqualTo("true");
assertThat(smtEngine.getValue(var).toString()).isEqualTo("3");
}
@Test
public void checkSimpleLIRAUnsat2() {
// x + y = 4 AND x * y = 4
Expr threeHalf = exprMgr.mkConst(new Rational(3, 2));
Expr varX = exprMgr.mkVar("x", exprMgr.integerType());
Expr varY = exprMgr.mkVar("y", exprMgr.realType());
Expr assertion1 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.MULT, varX, varY), threeHalf);
Expr assertion2 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.PLUS, varX, varY), threeHalf);
smtEngine.assertFormula(assertion1);
smtEngine.assertFormula(assertion2);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
}
@Test
public void checkSimpleLIRASat() {
// x + y = 8/5 AND x > 0 AND y > 0 AND x < 8/5 AND y < 8/5
Expr zero = exprMgr.mkConst(new Rational(0));
Expr eightFifth = exprMgr.mkConst(new Rational(8, 5));
Expr varX = exprMgr.mkVar("x", exprMgr.realType());
Expr varY = exprMgr.mkVar("y", exprMgr.integerType());
Expr assertion1 = exprMgr.mkExpr(Kind.GT, varX, zero);
Expr assertion2 = exprMgr.mkExpr(Kind.GT, varY, zero);
Expr assertion3 = exprMgr.mkExpr(Kind.LT, varX, eightFifth);
Expr assertion4 = exprMgr.mkExpr(Kind.LT, varY, eightFifth);
Expr assertion5 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.PLUS, varX, varY), eightFifth);
smtEngine.assertFormula(assertion1);
smtEngine.assertFormula(assertion2);
smtEngine.assertFormula(assertion3);
smtEngine.assertFormula(assertion4);
smtEngine.assertFormula(assertion5);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
@Test
public void checkSimpleLRASat() {
// x * y = 8/5 AND x < 4/5
Expr fourFifth = exprMgr.mkConst(new Rational(4, 5));
Expr eightFifth = exprMgr.mkConst(new Rational(8, 5));
Expr varX = exprMgr.mkVar("x", exprMgr.realType());
Expr varY = exprMgr.mkVar("y", exprMgr.realType());
Expr assertion1 =
exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.NONLINEAR_MULT, varX, varY), eightFifth);
Expr assertion2 = exprMgr.mkExpr(Kind.LT, varX, fourFifth);
smtEngine.assertFormula(assertion1);
smtEngine.assertFormula(assertion2);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
/** Exponents may only be natural number constants. */
@Test
public void checkSimplePow() {
// x ^ 2 = 4 AND x ^ 3 = 8
Expr two = exprMgr.mkConst(new Rational(2));
Expr three = exprMgr.mkConst(new Rational(3));
Expr four = exprMgr.mkConst(new Rational(4));
Expr eight = exprMgr.mkConst(new Rational(8));
Expr varX = exprMgr.mkVar("x", exprMgr.realType());
Expr assertion1 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.POW, varX, two), four);
Expr assertion2 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.POW, varX, three), eight);
smtEngine.assertFormula(assertion1);
smtEngine.assertFormula(assertion2);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
/**
* Do not ever try to use decimals in a new Rational that has only a 0 as decimal. This will
* SIGSEV CVC4!
*/
@Test
public void checkSimpleFPSat() {
// x * y = 1/4
RoundingMode rm = RoundingMode.roundNearestTiesToAway;
Expr rmExpr = exprMgr.mkConst(rm);
Expr oneFourth =
exprMgr.mkConst(new FloatingPoint(new FloatingPointSize(8, 24), rm, new Rational(1, 4)));
Expr varX = exprMgr.mkVar("x", exprMgr.mkFloatingPointType(8, 24));
Expr varY = exprMgr.mkVar("y", exprMgr.mkFloatingPointType(8, 24));
Expr assertion1 =
exprMgr.mkExpr(
Kind.FLOATINGPOINT_EQ,
exprMgr.mkExpr(Kind.FLOATINGPOINT_MULT, rmExpr, varX, varY),
oneFourth);
smtEngine.assertFormula(assertion1);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
@Test
public void checkSimpleFPUnsat() {
// x * y = 1/4 AND x > 0 AND y < 0
RoundingMode rm = RoundingMode.roundNearestTiesToAway;
Expr rmExpr = exprMgr.mkConst(rm);
Expr oneFourth =
exprMgr.mkConst(new FloatingPoint(new FloatingPointSize(8, 24), rm, new Rational(1, 4)));
Expr zero =
exprMgr.mkConst(
new FloatingPoint(
new FloatingPointSize(8, 24),
RoundingMode.roundNearestTiesToAway,
new Rational(0)));
Expr varX = exprMgr.mkVar("x", exprMgr.mkFloatingPointType(8, 24));
Expr varY = exprMgr.mkVar("y", exprMgr.mkFloatingPointType(8, 24));
Expr assertion1 =
exprMgr.mkExpr(
Kind.FLOATINGPOINT_EQ,
exprMgr.mkExpr(Kind.FLOATINGPOINT_MULT, rmExpr, varX, varY),
oneFourth);
Expr assertion2 = exprMgr.mkExpr(Kind.FLOATINGPOINT_GT, varX, zero);
Expr assertion3 = exprMgr.mkExpr(Kind.FLOATINGPOINT_LT, varY, zero);
smtEngine.assertFormula(assertion1);
smtEngine.assertFormula(assertion2);
smtEngine.assertFormula(assertion3);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
}
@Test
public void checkSimpleLRAUnsat() {
// x + y = x * y AND x - 1 = 0
Expr zero = exprMgr.mkConst(new Rational(0));
Expr one = exprMgr.mkConst(new Rational(1));
Expr varX = exprMgr.mkVar("x", exprMgr.realType());
Expr varY = exprMgr.mkVar("y", exprMgr.realType());
Expr assertion1 =
exprMgr.mkExpr(
Kind.EQUAL,
exprMgr.mkExpr(Kind.NONLINEAR_MULT, varX, varY),
exprMgr.mkExpr(Kind.PLUS, varX, varY));
Expr assertion2 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.MINUS, varX, one), zero);
smtEngine.assertFormula(assertion1);
smtEngine.assertFormula(assertion2);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
}
@Test
public void checkSimpleLRAUnsat2() {
// x + y = 3/2 AND x * y = 3/2
Expr threeHalf = exprMgr.mkConst(new Rational(3, 2));
Expr varX = exprMgr.mkVar("x", exprMgr.realType());
Expr varY = exprMgr.mkVar("y", exprMgr.realType());
Expr assertion1 =
exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.NONLINEAR_MULT, varX, varY), threeHalf);
Expr assertion2 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.PLUS, varX, varY), threeHalf);
smtEngine.assertFormula(assertion1);
smtEngine.assertFormula(assertion2);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
}
@Test
public void checkSimpleIncrementalSolving() {
// x + y = 3/2 AND x * y = 3/2 (AND x - 1 = 0)
Expr zero = exprMgr.mkConst(new Rational(0));
Expr one = exprMgr.mkConst(new Rational(1));
Expr threeHalf = exprMgr.mkConst(new Rational(3, 2));
Expr varX = exprMgr.mkVar("x", exprMgr.realType());
Expr varY = exprMgr.mkVar("y", exprMgr.realType());
// this alone is SAT
Expr assertion1 =
exprMgr.mkExpr(
Kind.EQUAL,
exprMgr.mkExpr(Kind.NONLINEAR_MULT, varX, varY),
exprMgr.mkExpr(Kind.PLUS, varX, varY));
// both 2 and 3 make it UNSAT (either one)
Expr assertion2 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.PLUS, varX, varY), threeHalf);
Expr assertion3 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.MINUS, varX, one), zero);
smtEngine.push();
smtEngine.assertFormula(assertion1);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
smtEngine.push();
smtEngine.assertFormula(assertion2);
satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
smtEngine.pop();
satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
smtEngine.push();
smtEngine.assertFormula(assertion3);
satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
smtEngine.pop();
satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
/** Note that model and getValue are seperate! */
@Test
public void checkInvalidModelGetValue() {
Expr assertion = exprMgr.mkConst(false);
Result result = smtEngine.checkSat(assertion);
assertThat(result.isSat()).isEqualTo(Sat.UNSAT);
Exception e =
assertThrows(edu.stanford.CVC4.Exception.class, () -> smtEngine.getValue(assertion));
assertThat(e.toString()).contains(INVALID_GETVALUE_STRING);
}
/** For reasons unknown you can get a model, but you can't do anything with it. */
@Test
public void checkInvalidModel() {
Result result = smtEngine.checkSat(exprMgr.mkConst(false));
assertThat(result.isSat()).isEqualTo(Sat.UNSAT);
Exception e = assertThrows(edu.stanford.CVC4.Exception.class, () -> smtEngine.getModel());
assertThat(e.toString()).contains(INVALID_MODEL_STRING);
}
/** It does not matter if you take an int or array or bv here, all result in the same error. */
@Test
public void checkInvalidTypeOperationsAssert() {
BitVectorType bvType = exprMgr.mkBitVectorType(16);
Expr bvVar = exprMgr.mkVar("bla", bvType);
Expr assertion = exprMgr.mkExpr(Kind.AND, bvVar, bvVar);
Exception e =
assertThrows(edu.stanford.CVC4.Exception.class, () -> smtEngine.assertFormula(assertion));
assertThat(e.toString()).contains("expecting a Boolean subexpression");
}
/** It does not matter if you take an int or array or bv here, all result in the same error. */
@Test
public void checkInvalidTypeOperationsCheckSat() {
BitVectorType bvType = exprMgr.mkBitVectorType(16);
Expr bvVar = exprMgr.mkVar("bla", bvType);
Expr assertion = exprMgr.mkExpr(Kind.AND, bvVar, bvVar);
Exception e =
assertThrows(edu.stanford.CVC4.Exception.class, () -> smtEngine.checkSat(assertion));
assertThat(e.toString()).contains("expecting a Boolean subexpression");
}
@Test
public void checkBvInvalidWidthAssertion() {
Expr bvOne = exprMgr.mkConst(new BitVector(0, 1));
Expr assertion = exprMgr.mkExpr(Kind.EQUAL, bvOne, bvOne);
Exception e =
assertThrows(edu.stanford.CVC4.Exception.class, () -> smtEngine.assertFormula(assertion));
assertThat(e.toString()).contains("constant of size 0");
}
@Test
public void checkBvInvalidWidthCheckSat() {
Expr bvOne = exprMgr.mkConst(new BitVector(0, 1));
Expr assertion = exprMgr.mkExpr(Kind.EQUAL, bvOne, bvOne);
Exception e =
assertThrows(edu.stanford.CVC4.Exception.class, () -> smtEngine.checkSat(assertion));
assertThat(e.toString()).contains("constant of size 0");
}
@Test
public void checkSimpleBvEqualitySat() {
// 1 + 0 = 1 with bitvectors
Expr bvOne = exprMgr.mkConst(new BitVector(16, 1));
Expr bvZero = exprMgr.mkConst(new BitVector(16, 0));
Expr assertion =
exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.BITVECTOR_PLUS, bvZero, bvOne), bvOne);
smtEngine.assertFormula(assertion);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
@Test
public void checkSimpleBvEqualityUnsat() {
// 0 + 1 = 2 UNSAT with bitvectors
Expr bvZero = exprMgr.mkConst(new BitVector(16, 0));
Expr bvOne = exprMgr.mkConst(new BitVector(16, 1));
Expr bvTwo = exprMgr.mkConst(new BitVector(16, 2));
Expr assertion =
exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.BITVECTOR_PLUS, bvZero, bvOne), bvTwo);
smtEngine.assertFormula(assertion);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
}
@Test
public void checkSimpleBvUnsat() {
// var + 1 = 0 & var < max bitvector & var > 0; both < and > signed
// Because of bitvector nature its UNSAT now
Expr bvVar = exprMgr.mkBoundVar(exprMgr.mkBitVectorType(16));
Expr bvOne = exprMgr.mkConst(new BitVector(16, 1));
Expr bvZero = exprMgr.mkConst(new BitVector(16, 0));
Expr assertion1 =
exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.BITVECTOR_PLUS, bvVar, bvOne), bvZero);
Expr assertion2 =
exprMgr.mkExpr(Kind.BITVECTOR_SLT, bvVar, exprMgr.mkConst(BitVector.mkMaxSigned(16)));
Expr assertion3 =
exprMgr.mkExpr(Kind.BITVECTOR_SGT, bvVar, exprMgr.mkConst(new BitVector(16, 0)));
smtEngine.assertFormula(assertion1);
smtEngine.assertFormula(assertion2);
smtEngine.assertFormula(assertion3);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
}
/*
* CVC4 fails some easy quantifier tests. To check wheter or not they really fail in CVC4 or due
* to JavaSMT we test them in the native API.
*/
@Test
public void checkQuantifierExistsIncomplete() {
// (not exists x . not b[x] = 0) AND (b[123] = 0) is SAT
setupArrayQuant();
Expr zero = exprMgr.mkConst(new Rational(0));
Expr xBound = exprMgr.mkBoundVar("x", exprMgr.integerType());
vectorExpr vec = new vectorExpr();
vec.add(xBound);
Expr quantifiedVars = exprMgr.mkExpr(Kind.BOUND_VAR_LIST, vec);
Expr aAtxEq0s = aAtxEq0.substitute(x, xBound);
Expr exists = exprMgr.mkExpr(Kind.EXISTS, quantifiedVars, exprMgr.mkExpr(Kind.NOT, aAtxEq0s));
Expr notExists = exprMgr.mkExpr(Kind.NOT, exists);
Expr select123 = exprMgr.mkExpr(Kind.SELECT, array, exprMgr.mkConst(new Rational(123)));
Expr selectEq0 = exprMgr.mkExpr(Kind.EQUAL, select123, zero);
Expr assertion = exprMgr.mkExpr(Kind.AND, notExists, selectEq0);
// assertFormula has a return value, check?
smtEngine.assertFormula(assertion);
Result satCheck = smtEngine.checkSat();
// CVC4 fails this test as incomplete
assertThat(satCheck.isUnknown()).isTrue();
assertThat(satCheck.whyUnknown()).isEqualTo(Result.UnknownExplanation.INCOMPLETE);
}
@Test
public void checkQuantifierEliminationLIA() {
// build formula: (forall x . ((x < 5) | (7 < x + y)))
// quantifier-free equivalent: (2 < y) or (>= y 3)
setupArrayQuant();
Expr three = exprMgr.mkConst(new Rational(3));
Expr five = exprMgr.mkConst(new Rational(5));
Expr seven = exprMgr.mkConst(new Rational(7));
Expr y = exprMgr.mkVar("y", exprMgr.integerType());
Expr first = exprMgr.mkExpr(Kind.LT, x, five);
Expr second = exprMgr.mkExpr(Kind.LT, seven, exprMgr.mkExpr(Kind.PLUS, x, y));
Expr body = exprMgr.mkExpr(Kind.OR, first, second);
Expr xBound = exprMgr.mkBoundVar("x", exprMgr.integerType());
vectorExpr vec = new vectorExpr();
vec.add(xBound);
Expr quantifiedVars = exprMgr.mkExpr(Kind.BOUND_VAR_LIST, vec);
Expr bodySubst = body.substitute(x, xBound);
Expr assertion = exprMgr.mkExpr(Kind.FORALL, quantifiedVars, bodySubst);
Expr result = smtEngine.doQuantifierElimination(assertion, true);
Expr resultCheck = exprMgr.mkExpr(Kind.GEQ, y, three);
assertThat(result.toString()).isEqualTo(resultCheck.toString());
}
@SuppressWarnings("unused")
@Test
public void checkQuantifierWithUf() throws FileNotFoundException, UnsupportedEncodingException {
Expr var = exprMgr.mkVar("var", exprMgr.integerType());
// start with a normal, free variable!
Expr boundVar = exprMgr.mkVar("boundVar", exprMgr.integerType());
Expr varIsOne = exprMgr.mkExpr(Kind.EQUAL, var, exprMgr.mkConst(new Rational(1)));
// try not to use 0 as this is the default value for CVC4 models
Expr boundVarIsTwo = exprMgr.mkExpr(Kind.EQUAL, boundVar, exprMgr.mkConst(new Rational(2)));
Expr boundVarIsOne = exprMgr.mkExpr(Kind.EQUAL, boundVar, exprMgr.mkConst(new Rational(1)));
String func = "func";
Type intType = exprMgr.integerType();
Type ufType = exprMgr.mkFunctionType(intType, intType);
Expr uf = exprMgr.mkVar(func, ufType);
Expr funcAtBoundVar = exprMgr.mkExpr(uf, boundVar);
Expr body =
exprMgr.mkExpr(Kind.AND, boundVarIsTwo, exprMgr.mkExpr(Kind.EQUAL, var, funcAtBoundVar));
// This is the bound variable used for boundVar
Expr boundVarBound = exprMgr.mkBoundVar("boundVar", exprMgr.integerType());
vectorExpr vec = new vectorExpr();
vec.add(boundVarBound);
Expr quantifiedVars = exprMgr.mkExpr(Kind.BOUND_VAR_LIST, vec);
// Subst all boundVar variables with the bound version
Expr bodySubst = body.substitute(boundVar, boundVarBound);
Expr quantFormula = exprMgr.mkExpr(Kind.EXISTS, quantifiedVars, bodySubst);
// var = 1 & boundVar = 1 & exists boundVar . ( boundVar = 2 & f(boundVar) = var )
Expr overallFormula = exprMgr.mkExpr(Kind.AND, varIsOne, boundVarIsOne, quantFormula);
smtEngine.assertFormula(overallFormula);
Result satCheck = smtEngine.checkSat();
// SAT
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
// check Model
// var = 1 & boundVar = 1 & exists boundVar . ( boundVar = 2 & f(2) = 1 )
// It seems like CVC4 can't return quantified variables,
// therefore we can't get a value for the uf!
assertThat(smtEngine.getValue(var).toString()).isEqualTo("1");
assertThat(smtEngine.getValue(boundVar).toString()).isEqualTo("1");
assertThat(smtEngine.getValue(funcAtBoundVar).toString()).isEqualTo("1");
assertThat(smtEngine.getValue(boundVarBound).toString()).isEqualTo("boundVar");
}
/**
* CVC4 does not support Array quantifier elimination. This is expected to fail! But it runs
* endlessly. So we can check interruption on it.
*/
@Test
public void checkInterruptBehaviour() {
setupArrayQuant();
Expr body = exprMgr.mkExpr(Kind.OR, aAtxEq0, aAtxEq1);
Expr xBound = exprMgr.mkBoundVar("x_b", exprMgr.integerType());
vectorExpr vec = new vectorExpr();
vec.add(xBound);
Expr quantifiedVars = exprMgr.mkExpr(Kind.BOUND_VAR_LIST, vec);
Expr bodySubst = body.substitute(x, xBound);
Expr assertion = exprMgr.mkExpr(Kind.FORALL, quantifiedVars, bodySubst);
Thread t =
new Thread(
() -> {
try {
// 1 is not enough!
Thread.sleep(10);
smtEngine.interrupt();
} catch (InterruptedException pE) {
throw new UnsupportedOperationException("Unexpected interrupt");
}
});
t.start();
// According to the API of CVC4 this should either throw a UnsafeInterruptedException if the
// SMTEngine is running or ModalException if the SMTEngine is not running. But it does not, it
// returns the input, but not in a way that its equal to the input.
Expr result = smtEngine.doQuantifierElimination(assertion, true);
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);
}
/** CVC4 does not support Bv quantifier elim. This is expected to fail! */
@Test
public void checkQuantifierEliminationBV() {
// build formula: exists y : bv[2]. x * y = 1
// quantifier-free equivalent: x = 1 | x = 3
// or extract_0_0 x = 1
int width = 2;
Expr xBv = exprMgr.mkVar("x_bv", exprMgr.mkBitVectorType(width));
Expr yBv = exprMgr.mkVar("y_bv", exprMgr.mkBitVectorType(width));
Expr body =
exprMgr.mkExpr(
Kind.EQUAL, exprMgr.mkExpr(Kind.MULT, xBv, yBv), exprMgr.mkConst(new BitVector(1)));
Expr xBound = exprMgr.mkBoundVar("y_bv", exprMgr.mkBitVectorType(width));
vectorExpr vec = new vectorExpr();
vec.add(xBound);
Expr quantifiedVars = exprMgr.mkExpr(Kind.BOUND_VAR_LIST, vec);
Expr bodySubst = body.substitute(yBv, xBound);
Expr assertion = exprMgr.mkExpr(Kind.EXISTS, quantifiedVars, bodySubst);
assertThrows(RuntimeException.class, () -> smtEngine.doQuantifierElimination(assertion, true));
}
@Test
public void checkArraySat() {
// ((x = 123) & (select(arr, 5) = 123)) => ((select(arr, 5) = x) & (x = 123))
Expr five = exprMgr.mkConst(new Rational(5));
Expr oneTwoThree = exprMgr.mkConst(new Rational(123));
Expr xInt = exprMgr.mkVar("x_int", exprMgr.integerType());
ArrayType arrayType = exprMgr.mkArrayType(exprMgr.integerType(), exprMgr.integerType());
Expr arr = exprMgr.mkVar("arr", arrayType);
Expr xEq123 = exprMgr.mkExpr(Kind.EQUAL, xInt, oneTwoThree);
Expr selAat5Eq123 =
exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.SELECT, arr, five), oneTwoThree);
Expr selAat5EqX = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.SELECT, arr, five), xInt);
Expr leftAnd = exprMgr.mkExpr(Kind.AND, xEq123, selAat5Eq123);
Expr rightAnd = exprMgr.mkExpr(Kind.AND, xEq123, selAat5EqX);
Expr impl = exprMgr.mkExpr(Kind.IMPLIES, leftAnd, rightAnd);
smtEngine.assertFormula(impl);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
@Test
public void checkArrayUnsat() {
// (x = 123) & (select(arr, 5) = 123) & (select(arr, 5) != x)
Expr five = exprMgr.mkConst(new Rational(5));
Expr oneTwoThree = exprMgr.mkConst(new Rational(123));
Expr xInt = exprMgr.mkVar("x_int", exprMgr.integerType());
ArrayType arrayType = exprMgr.mkArrayType(exprMgr.integerType(), exprMgr.integerType());
Expr arr = exprMgr.mkVar("arr", arrayType);
Expr xEq123 = exprMgr.mkExpr(Kind.EQUAL, xInt, oneTwoThree);
Expr selAat5Eq123 =
exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.SELECT, arr, five), oneTwoThree);
Expr selAat5NotEqX =
exprMgr.mkExpr(
Kind.NOT, exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.SELECT, arr, five), xInt));
Expr assertion = exprMgr.mkExpr(Kind.AND, xEq123, selAat5Eq123, selAat5NotEqX);
smtEngine.assertFormula(assertion);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
}
@Test
public void checkUnsatCore() {
// (a & b) & (not(a OR b))
// Enable UNSAT Core first!
smtEngine.setOption("produce-unsat-cores", new SExpr(true));
Type boolType = exprMgr.booleanType();
Expr a = exprMgr.mkVar("a", boolType);
Expr b = exprMgr.mkVar("b", boolType);
Expr aAndb = exprMgr.mkExpr(Kind.AND, a, b);
Expr notaOrb = exprMgr.mkExpr(Kind.NOT, exprMgr.mkExpr(Kind.OR, a, b));
smtEngine.assertFormula(aAndb);
smtEngine.assertFormula(notaOrb);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
UnsatCore unsatCore = smtEngine.getUnsatCore();
// UnsatCores are iterable
for (Expr 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))
Expr zero = exprMgr.mkConst(new Rational(0));
Expr one = exprMgr.mkConst(new Rational(1));
Type boolType = exprMgr.booleanType();
Type intType = exprMgr.integerType();
// You may use custom sorts just like bool or int
SortType mySort = exprMgr.mkSort("f");
// Type for UFs later
Type mySortToInt = exprMgr.mkFunctionType(mySort, intType);
Type intToBool = exprMgr.mkFunctionType(intType, boolType);
Expr xTyped = exprMgr.mkVar("x", mySort);
Expr yTyped = exprMgr.mkVar("y", mySort);
// declare UFs
Expr f = exprMgr.mkVar("f", mySortToInt);
Expr p = exprMgr.mkVar("p", intToBool);
// Apply UFs
Expr fx = exprMgr.mkExpr(Kind.APPLY_UF, f, xTyped);
Expr fy = exprMgr.mkExpr(Kind.APPLY_UF, f, yTyped);
Expr sum = exprMgr.mkExpr(Kind.PLUS, fx, fy);
Expr p0 = exprMgr.mkExpr(Kind.APPLY_UF, p, zero);
Expr pfy = exprMgr.mkExpr(Kind.APPLY_UF, p, fy);
// Make some assumptions
Expr assumptions =
exprMgr.mkExpr(
Kind.AND,
exprMgr.mkExpr(Kind.LEQ, zero, fx),
exprMgr.mkExpr(Kind.LEQ, zero, fy),
exprMgr.mkExpr(Kind.LEQ, sum, one),
p0.notExpr(),
pfy);
smtEngine.assertFormula(assumptions);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
@Test
public void checkBooleanUFDeclaration() {
Type boolType = exprMgr.booleanType();
Type intType = exprMgr.integerType();
// arg is bool, return is int
Type ufType = exprMgr.mkFunctionType(boolType, intType);
Expr uf = exprMgr.mkVar("fun_bi", ufType);
Expr ufTrue = exprMgr.mkExpr(uf, exprMgr.mkConst(true));
Expr ufFalse = exprMgr.mkExpr(uf, exprMgr.mkConst(false));
Expr assumptions = exprMgr.mkExpr(Kind.NOT, exprMgr.mkExpr(Kind.EQUAL, ufTrue, ufFalse));
smtEngine.assertFormula(assumptions);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
@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
Expr zero = exprMgr.mkConst(new Rational(0));
Expr one = exprMgr.mkConst(new Rational(1));
Type intType = exprMgr.integerType();
// Type for UFs later
Type intToInt = exprMgr.mkFunctionType(intType, intType);
Expr xInt = exprMgr.mkVar("x", intType);
Expr yInt = exprMgr.mkVar("y", intType);
// declare UFs
Expr f = exprMgr.mkVar("f", intToInt);
// Apply UFs
Expr fx = exprMgr.mkExpr(Kind.APPLY_UF, f, xInt);
Expr fy = exprMgr.mkExpr(Kind.APPLY_UF, f, yInt);
Expr plus = exprMgr.mkExpr(Kind.PLUS, fx, fy);
// Make some assumptions
Expr assumptions1 =
exprMgr.mkExpr(
Kind.AND, exprMgr.mkExpr(Kind.LEQ, zero, fx), exprMgr.mkExpr(Kind.LEQ, zero, fy));
Expr assumptions2 =
exprMgr.mkExpr(
Kind.AND,
exprMgr.mkExpr(Kind.EQUAL, fx, exprMgr.mkExpr(Kind.PLUS, xInt, one)),
exprMgr.mkExpr(Kind.EQUAL, fy, exprMgr.mkExpr(Kind.MINUS, yInt, one)),
exprMgr.mkExpr(Kind.EQUAL, plus, xInt),
exprMgr.mkExpr(Kind.EQUAL, plus, yInt));
smtEngine.assertFormula(assumptions1);
smtEngine.assertFormula(assumptions2);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.UNSAT);
}
@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
Expr one = exprMgr.mkConst(new Rational(1));
Type intType = exprMgr.integerType();
// Type for UFs later
Type intToInt = exprMgr.mkFunctionType(intType, intType);
Expr xInt = exprMgr.mkVar("x", intType);
Expr yInt = exprMgr.mkVar("y", intType);
// declare UFs
Expr f = exprMgr.mkVar("f", intToInt);
// Apply UFs
Expr fx = exprMgr.mkExpr(Kind.APPLY_UF, f, xInt);
Expr fy = exprMgr.mkExpr(Kind.APPLY_UF, f, yInt);
Expr plus = exprMgr.mkExpr(Kind.PLUS, fx, fy);
Expr plusEqx = exprMgr.mkExpr(Kind.EQUAL, plus, xInt);
Expr plusEqy = exprMgr.mkExpr(Kind.EQUAL, plus, yInt);
Expr xEqy = exprMgr.mkExpr(Kind.EQUAL, yInt, xInt);
Expr xEqyImplplusEqxAndy =
exprMgr.mkExpr(Kind.IMPLIES, xEqy, exprMgr.mkExpr(Kind.AND, plusEqx, plusEqy));
Expr assumptions =
exprMgr.mkExpr(
Kind.AND,
exprMgr.mkExpr(Kind.EQUAL, fx, exprMgr.mkExpr(Kind.PLUS, xInt, one)),
exprMgr.mkExpr(Kind.EQUAL, fy, exprMgr.mkExpr(Kind.MINUS, yInt, one)),
xEqyImplplusEqxAndy);
smtEngine.assertFormula(assumptions);
Result satCheck = smtEngine.checkSat();
assertThat(satCheck.isSat()).isEqualTo(Sat.SAT);
}
/** Sets up array and quantifier based formulas for tests. */
public void setupArrayQuant() {
Expr zero = exprMgr.mkConst(new Rational(0));
Expr one = exprMgr.mkConst(new Rational(1));
x = exprMgr.mkVar("x", exprMgr.integerType());
ArrayType arrayType = exprMgr.mkArrayType(exprMgr.integerType(), exprMgr.integerType());
array = exprMgr.mkVar("a", arrayType);
aAtxEq0 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.SELECT, array, x), zero);
aAtxEq1 = exprMgr.mkExpr(Kind.EQUAL, exprMgr.mkExpr(Kind.SELECT, array, x), one);
}
}
| 35,802 | 37.088298 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4NumeralFormulaManager.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.cvc4;
import static edu.stanford.CVC4.Kind.DIVISION;
import static edu.stanford.CVC4.Kind.INTS_DIVISION;
import static edu.stanford.CVC4.Kind.INTS_MODULUS;
import static edu.stanford.CVC4.Kind.ITE;
import static edu.stanford.CVC4.Kind.MINUS;
import static edu.stanford.CVC4.Kind.MULT;
import static edu.stanford.CVC4.Kind.PLUS;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.Kind;
import edu.stanford.CVC4.Rational;
import edu.stanford.CVC4.Type;
import edu.stanford.CVC4.vectorExpr;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
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 CVC4NumeralFormulaManager<
ParamFormulaType extends NumeralFormula, ResultFormulaType extends NumeralFormula>
extends AbstractNumeralFormulaManager<
Expr, Type, ExprManager, ParamFormulaType, ResultFormulaType, Expr> {
/**
* 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. */
private static final ImmutableSet<Kind> NUMERIC_FUNCTIONS =
ImmutableSet.of(PLUS, MINUS, MULT, DIVISION, INTS_DIVISION, INTS_MODULUS);
protected final ExprManager exprManager;
CVC4NumeralFormulaManager(CVC4FormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
exprManager = pCreator.getEnv();
}
protected abstract Type getNumeralType();
@Override
protected boolean isNumeral(Expr pVal) {
return (pVal.getType().isInteger() || pVal.getType().isReal()) && pVal.isConst();
}
/**
* 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 CVC4 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(Expr val) {
Set<Expr> finished = new HashSet<>();
Deque<Expr> waitlist = new ArrayDeque<>();
waitlist.add(val);
while (!waitlist.isEmpty()) {
Expr 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 Expr makeNumberImpl(long i) {
// we connot use "new Rational(long)", because it uses "unsigned long".
return makeNumberImpl(Long.toString(i));
}
@Override
protected Expr makeNumberImpl(BigInteger pI) {
return makeNumberImpl(pI.toString());
}
@Override
protected Expr makeNumberImpl(String pI) {
if (!RATIONAL_NUMBER.matcher(pI).matches()) {
throw new NumberFormatException("number is not an rational value: " + pI);
}
return exprManager.mkConst(Rational.fromDecimal(pI));
}
@Override
protected Expr makeVariableImpl(String varName) {
Type type = getNumeralType();
return getFormulaCreator().makeVariable(type, varName);
}
@Override
protected Expr multiply(Expr pParam1, Expr pParam2) {
if (consistsOfNumerals(pParam1) || consistsOfNumerals(pParam2)) {
return exprManager.mkExpr(Kind.MULT, pParam1, pParam2);
} else {
return super.multiply(pParam1, pParam2);
}
}
@Override
protected Expr modulo(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.INTS_MODULUS, pParam1, pParam2);
}
@Override
protected Expr negate(Expr pParam1) {
return exprManager.mkExpr(Kind.UMINUS, pParam1);
}
@Override
protected Expr add(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.PLUS, pParam1, pParam2);
}
@Override
protected Expr subtract(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.MINUS, pParam1, pParam2);
}
@Override
protected Expr equal(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.EQUAL, pParam1, pParam2);
}
@Override
protected Expr greaterThan(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.GT, pParam1, pParam2);
}
@Override
protected Expr greaterOrEquals(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.GEQ, pParam1, pParam2);
}
@Override
protected Expr lessThan(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.LT, pParam1, pParam2);
}
@Override
protected Expr lessOrEquals(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.LEQ, pParam1, pParam2);
}
@Override
protected Expr distinctImpl(List<Expr> pParam) {
vectorExpr param = new vectorExpr();
pParam.forEach(param::add);
return exprManager.mkExpr(Kind.DISTINCT, param);
}
}
| 5,901 | 30.731183 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4QuantifiedFormulaManager.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.cvc4;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.Kind;
import edu.stanford.CVC4.SmtEngine;
import edu.stanford.CVC4.Type;
import edu.stanford.CVC4.vectorExpr;
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 CVC4QuantifiedFormulaManager
extends AbstractQuantifiedFormulaManager<Expr, Type, ExprManager, Expr> {
private final ExprManager exprManager;
protected CVC4QuantifiedFormulaManager(
FormulaCreator<Expr, Type, ExprManager, Expr> pFormulaCreator) {
super(pFormulaCreator);
exprManager = pFormulaCreator.getEnv();
}
/*
* (non-Javadoc) CVC4s quantifier support is dependent on the options used.
* Without any options it tends to run infenitly 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 Expr eliminateQuantifiers(Expr pExtractInfo)
throws SolverException, InterruptedException {
SmtEngine smtEngine = new SmtEngine(exprManager);
Expr eliminated = pExtractInfo;
// The first bool is for partial or full elimination. true is full
// The second bool (optional; 2 methods) is whether to output warnings or not, such as when an
// unexpected logic is used.
try {
eliminated = smtEngine.doQuantifierElimination(pExtractInfo, true);
} catch (RuntimeException e) {
// quantifier elimination failed, simply return the input
}
// We don't delete it in the prover.close(), is there a reason for that?
smtEngine.delete();
return eliminated;
}
/*
* Makes the quantifier entered in CVC4. Note that CVC4 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 uses their internal Lists
* for the variable list in quantifiers.
*/
@Override
public Expr mkQuantifier(Quantifier pQ, List<Expr> pVars, Expr pBody) {
if (pVars.isEmpty()) {
throw new IllegalArgumentException("Empty variable list for quantifier.");
} else {
// CVC4 uses its own lists for quantifier that may only have bound vars
vectorExpr vec = new vectorExpr();
Expr 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 (Expr var : pVars) {
Expr boundCopy = ((CVC4FormulaCreator) formulaCreator).makeBoundCopy(var);
vec.add(boundCopy);
substBody = substBody.substitute(var, boundCopy);
}
Expr quantifiedVars = exprManager.mkExpr(Kind.BOUND_VAR_LIST, vec);
Kind quant = pQ == Quantifier.EXISTS ? Kind.EXISTS : Kind.FORALL;
return exprManager.mkExpr(quant, quantifiedVars, substBody);
}
}
}
| 3,931 | 40.389474 | 98 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4RationalFormulaManager.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.cvc4;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.Kind;
import edu.stanford.CVC4.Type;
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 CVC4RationalFormulaManager
extends CVC4NumeralFormulaManager<NumeralFormula, RationalFormula>
implements RationalFormulaManager {
CVC4RationalFormulaManager(
CVC4FormulaCreator pCreator, NonLinearArithmetic pNonLinearArithmetic) {
super(pCreator, pNonLinearArithmetic);
}
@Override
protected Type getNumeralType() {
return getFormulaCreator().getRationalType();
}
@Override
protected Expr makeNumberImpl(double pNumber) {
return makeNumberImpl(Double.toString(pNumber));
}
@Override
protected Expr makeNumberImpl(BigDecimal pNumber) {
return makeNumberImpl(pNumber.toPlainString());
}
@Override
public Expr divide(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.DIVISION, pParam1, pParam2);
}
@Override
protected Expr floor(Expr pNumber) {
return exprManager.mkExpr(Kind.TO_INTEGER, pNumber);
}
}
| 1,480 | 26.943396 | 78 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4SLFormulaManager.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.cvc4;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.Kind;
import edu.stanford.CVC4.Type;
import org.sosy_lab.java_smt.basicimpl.AbstractSLFormulaManager;
public class CVC4SLFormulaManager extends AbstractSLFormulaManager<Expr, Type, ExprManager, Expr> {
private final ExprManager exprManager;
protected CVC4SLFormulaManager(CVC4FormulaCreator pCreator) {
super(pCreator);
exprManager = pCreator.getEnv();
}
@Override
protected Expr makeStar(Expr e1, Expr e2) {
return exprManager.mkExpr(Kind.SEP_STAR, e1, e2);
}
@Override
protected Expr makePointsTo(Expr pPtr, Expr pTo) {
return exprManager.mkExpr(Kind.SEP_PTO, pPtr, pTo);
}
@Override
protected Expr makeMagicWand(Expr pE1, Expr pE2) {
return exprManager.mkExpr(Kind.SEP_WAND, pE1, pE2);
}
@Override
protected Expr makeEmptyHeap(Type pT1, Type pT2) {
return exprManager.mkExpr(Kind.SEP_EMP, pT1.mkGroundTerm(), pT2.mkGroundTerm());
}
@Override
protected Expr makeNilElement(Type pType) {
return exprManager.mkExpr(Kind.SEP_NIL, pType.mkGroundTerm());
}
}
| 1,407 | 26.607843 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4SolverContext.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.cvc4;
import edu.stanford.CVC4.CVC4JNI;
import edu.stanford.CVC4.Configuration;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.SExpr;
import edu.stanford.CVC4.SmtEngine;
import java.util.Set;
import java.util.function.Consumer;
import java.util.logging.Level;
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 CVC4SolverContext extends AbstractSolverContext {
// creator is final, except after closing, then null.
private CVC4FormulaCreator creator;
private final ShutdownNotifier shutdownNotifier;
private final int randomSeed;
private CVC4SolverContext(
CVC4FormulaCreator creator,
CVC4FormulaManager manager,
ShutdownNotifier pShutdownNotifier,
int pRandomSeed) {
super(manager);
this.creator = creator;
shutdownNotifier = pShutdownNotifier;
randomSeed = pRandomSeed;
}
public static SolverContext create(
LogManager pLogger,
ShutdownNotifier pShutdownNotifier,
int randomSeed,
NonLinearArithmetic pNonLinearArithmetic,
FloatingPointRoundingMode pFloatingPointRoundingMode,
Consumer<String> pLoader) {
pLoader.accept("cvc4jni");
// ExprManager is the central class for creating expressions/terms/formulae.
ExprManager exprManager = new ExprManager();
CVC4FormulaCreator creator = new CVC4FormulaCreator(exprManager);
// set common options.
// temporary SmtEngine instance, until ExprManager.getOptions() works without SegFault.
SmtEngine smtEngine = new SmtEngine(exprManager);
smtEngine.setOption("output-language", new SExpr("smt2"));
smtEngine.setOption("random-seed", new SExpr(randomSeed));
// Set Strings option to enable all String features (such as lessOrEquals)
smtEngine.setOption("strings-exp", new SExpr(true));
// smtEngine.delete();
// Create managers
CVC4UFManager functionTheory = new CVC4UFManager(creator);
CVC4BooleanFormulaManager booleanTheory = new CVC4BooleanFormulaManager(creator);
CVC4IntegerFormulaManager integerTheory =
new CVC4IntegerFormulaManager(creator, pNonLinearArithmetic);
CVC4RationalFormulaManager rationalTheory =
new CVC4RationalFormulaManager(creator, pNonLinearArithmetic);
CVC4BitvectorFormulaManager bitvectorTheory =
new CVC4BitvectorFormulaManager(creator, booleanTheory);
CVC4FloatingPointFormulaManager fpTheory;
if (Configuration.isBuiltWithSymFPU()) {
fpTheory = new CVC4FloatingPointFormulaManager(creator, pFloatingPointRoundingMode);
} else {
fpTheory = null;
pLogger.log(Level.INFO, "CVC4 was built without support for FloatingPoint theory");
// throw new AssertionError("CVC4 was built without support for FloatingPoint theory");
}
CVC4QuantifiedFormulaManager qfTheory = new CVC4QuantifiedFormulaManager(creator);
CVC4ArrayFormulaManager arrayTheory = new CVC4ArrayFormulaManager(creator);
CVC4SLFormulaManager slTheory = new CVC4SLFormulaManager(creator);
CVC4StringFormulaManager strTheory = new CVC4StringFormulaManager(creator);
CVC4FormulaManager manager =
new CVC4FormulaManager(
creator,
functionTheory,
booleanTheory,
integerTheory,
rationalTheory,
bitvectorTheory,
fpTheory,
qfTheory,
arrayTheory,
slTheory,
strTheory);
return new CVC4SolverContext(creator, manager, pShutdownNotifier, randomSeed);
}
@Override
public String getVersion() {
return "CVC4 " + CVC4JNI.Configuration_getVersionString();
}
@Override
public void close() {
if (creator != null) {
creator.getEnv().delete();
creator = null;
}
}
@Override
public Solvers getSolverName() {
return Solvers.CVC4;
}
@Override
public ProverEnvironment newProverEnvironment0(Set<ProverOptions> pOptions) {
return new CVC4TheoremProver(
creator,
shutdownNotifier,
randomSeed,
pOptions,
getFormulaManager().getBooleanFormulaManager());
}
@Override
protected boolean supportsAssumptionSolving() {
return false;
}
@Override
protected InterpolatingProverEnvironment<?> newProverEnvironmentWithInterpolation0(
Set<ProverOptions> pSet) {
throw new UnsupportedOperationException("CVC4 does not support interpolation");
}
@Override
protected OptimizationProverEnvironment newOptimizationProverEnvironment0(
Set<ProverOptions> pSet) {
throw new UnsupportedOperationException("CVC4 does not support optimization");
}
}
| 5,430 | 33.592357 | 93 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4StringFormulaManager.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
//
// SPDX-License-Identifier: Apache-2.0
package org.sosy_lab.java_smt.solvers.cvc4;
import com.google.common.base.Preconditions;
import edu.stanford.CVC4.CVC4String;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.Kind;
import edu.stanford.CVC4.Type;
import edu.stanford.CVC4.vectorExpr;
import java.util.List;
import org.sosy_lab.java_smt.basicimpl.AbstractStringFormulaManager;
class CVC4StringFormulaManager extends AbstractStringFormulaManager<Expr, Type, ExprManager, Expr> {
private final ExprManager exprManager;
CVC4StringFormulaManager(CVC4FormulaCreator pCreator) {
super(pCreator);
exprManager = pCreator.getEnv();
}
@Override
protected Expr makeStringImpl(String pValue) {
// The boolean enables escape characters!
return exprManager.mkConst(new CVC4String(pValue, true));
}
@Override
protected Expr makeVariableImpl(String varName) {
Type type = getFormulaCreator().getStringType();
return getFormulaCreator().makeVariable(type, varName);
}
@Override
protected Expr equal(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.EQUAL, pParam1, pParam2);
}
@Override
protected Expr greaterThan(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.STRING_LT, pParam2, pParam1);
}
@Override
protected Expr greaterOrEquals(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.STRING_LEQ, pParam2, pParam1);
}
@Override
protected Expr lessThan(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.STRING_LT, pParam1, pParam2);
}
@Override
protected Expr lessOrEquals(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.STRING_LEQ, pParam1, pParam2);
}
@Override
protected Expr length(Expr pParam) {
return exprManager.mkExpr(Kind.STRING_LENGTH, pParam);
}
@Override
protected Expr concatImpl(List<Expr> parts) {
Preconditions.checkArgument(parts.size() > 1);
vectorExpr vector = new vectorExpr();
parts.forEach(vector::add);
return exprManager.mkExpr(Kind.STRING_CONCAT, vector);
}
@Override
protected Expr prefix(Expr prefix, Expr str) {
return exprManager.mkExpr(Kind.STRING_PREFIX, prefix, str);
}
@Override
protected Expr suffix(Expr suffix, Expr str) {
return exprManager.mkExpr(Kind.STRING_SUFFIX, suffix, str);
}
@Override
protected Expr in(Expr str, Expr regex) {
return exprManager.mkExpr(Kind.STRING_IN_REGEXP, str, regex);
}
@Override
protected Expr contains(Expr str, Expr part) {
return exprManager.mkExpr(Kind.STRING_STRCTN, str, part);
}
@Override
protected Expr indexOf(Expr str, Expr part, Expr startIndex) {
return exprManager.mkExpr(Kind.STRING_STRIDOF, str, part, startIndex);
}
@Override
protected Expr charAt(Expr str, Expr index) {
return exprManager.mkExpr(Kind.STRING_CHARAT, str, index);
}
@Override
protected Expr substring(Expr str, Expr index, Expr length) {
return exprManager.mkExpr(Kind.STRING_SUBSTR, str, index, length);
}
@Override
protected Expr replace(Expr fullStr, Expr target, Expr replacement) {
return exprManager.mkExpr(Kind.STRING_STRREPL, fullStr, target, replacement);
}
@Override
protected Expr replaceAll(Expr fullStr, Expr target, Expr replacement) {
return exprManager.mkExpr(Kind.STRING_STRREPLALL, fullStr, target, replacement);
}
@Override
protected Expr makeRegexImpl(String value) {
Expr str = makeStringImpl(value);
return exprManager.mkExpr(Kind.STRING_TO_REGEXP, str);
}
@Override
protected Expr noneImpl() {
return exprManager.mkExpr(Kind.REGEXP_EMPTY, new vectorExpr());
}
@Override
protected Expr allImpl() {
return exprManager.mkExpr(Kind.REGEXP_COMPLEMENT, noneImpl());
}
@Override
protected Expr allCharImpl() {
return exprManager.mkExpr(Kind.REGEXP_SIGMA, new vectorExpr());
}
@Override
protected Expr range(Expr start, Expr end) {
return exprManager.mkExpr(Kind.REGEXP_RANGE, start, end);
}
@Override
protected Expr concatRegexImpl(List<Expr> parts) {
Preconditions.checkArgument(parts.size() > 1);
vectorExpr vector = new vectorExpr();
parts.forEach(vector::add);
return exprManager.mkExpr(Kind.REGEXP_CONCAT, vector);
}
@Override
protected Expr union(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.REGEXP_UNION, pParam1, pParam2);
}
@Override
protected Expr intersection(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.REGEXP_INTER, pParam1, pParam2);
}
@Override
protected Expr closure(Expr pParam) {
return exprManager.mkExpr(Kind.REGEXP_STAR, pParam);
}
@Override
protected Expr complement(Expr pParam) {
return exprManager.mkExpr(Kind.REGEXP_COMPLEMENT, pParam);
}
@Override
protected Expr difference(Expr pParam1, Expr pParam2) {
return exprManager.mkExpr(Kind.REGEXP_DIFF, pParam1, pParam2);
}
@Override
protected Expr toIntegerFormula(Expr pParam) {
return exprManager.mkExpr(Kind.STRING_STOI, pParam);
}
@Override
protected Expr toStringFormula(Expr pParam) {
return exprManager.mkExpr(Kind.STRING_ITOS, pParam);
}
}
| 5,380 | 26.737113 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4TheoremProver.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.cvc4;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.ExprManagerMapCollection;
import edu.stanford.CVC4.Result;
import edu.stanford.CVC4.SExpr;
import edu.stanford.CVC4.SmtEngine;
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.checkerframework.checker.nullness.qual.Nullable;
import org.sosy_lab.common.ShutdownNotifier;
import org.sosy_lab.java_smt.api.BasicProverEnvironment;
import org.sosy_lab.java_smt.api.BooleanFormula;
import org.sosy_lab.java_smt.api.BooleanFormulaManager;
import org.sosy_lab.java_smt.api.Evaluator;
import org.sosy_lab.java_smt.api.Model.ValueAssignment;
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.ShutdownHook;
class CVC4TheoremProver extends AbstractProverWithAllSat<Void>
implements ProverEnvironment, BasicProverEnvironment<Void> {
private final CVC4FormulaCreator creator;
SmtEngine smtEngine; // final except for SL theory
private boolean changedSinceLastSatQuery = false;
/** Tracks formulas on the stack, needed for model generation. */
protected final Deque<List<Expr>> assertedFormulas = new ArrayDeque<>();
/**
* The local exprManager allows to set options per Prover (and not globally). See <a
* href="https://github.com/CVC4/CVC4/issues/3055">Issue 3055</a> for details.
*
* <p>TODO If the overhead of importing/exporting the expressions is too expensive, we can disable
* this behavior. This change would cost us the flexibility of setting options per Prover.
*/
private final ExprManager exprManager = new ExprManager();
/** We copy expression between different ExprManagers. The map serves as cache. */
private final ExprManagerMapCollection exportMapping = new ExprManagerMapCollection();
// CVC4 does not support separation logic in incremental mode.
private final boolean incremental;
protected CVC4TheoremProver(
CVC4FormulaCreator pFormulaCreator,
ShutdownNotifier pShutdownNotifier,
int randomSeed,
Set<ProverOptions> pOptions,
BooleanFormulaManager pBmgr) {
super(pOptions, pBmgr, pShutdownNotifier);
creator = pFormulaCreator;
smtEngine = new SmtEngine(exprManager);
incremental = !enableSL;
assertedFormulas.push(new ArrayList<>()); // create initial level
setOptions(randomSeed, pOptions);
}
private void setOptions(int randomSeed, Set<ProverOptions> pOptions) {
smtEngine.setOption("incremental", new SExpr(incremental));
if (pOptions.contains(ProverOptions.GENERATE_MODELS)) {
smtEngine.setOption("produce-models", new SExpr(true));
}
if (pOptions.contains(ProverOptions.GENERATE_UNSAT_CORE)) {
smtEngine.setOption("produce-unsat-cores", new SExpr(true));
}
smtEngine.setOption("produce-assertions", new SExpr(true));
smtEngine.setOption("dump-models", new SExpr(true));
// smtEngine.setOption("produce-unsat-cores", new SExpr(true));
smtEngine.setOption("output-language", new SExpr("smt2"));
smtEngine.setOption("random-seed", new SExpr(randomSeed));
// Set Strings option to enable all String features (such as lessOrEquals)
smtEngine.setOption("strings-exp", new SExpr(true));
// Enable more complete quantifier solving (for more information see
// CVC4QuantifiedFormulaManager)
smtEngine.setOption("full-saturate-quant", new SExpr(true));
}
protected void setOptionForIncremental() {
smtEngine.setOption("incremental", new SExpr(true));
}
/** import an expression from global context into this prover's context. */
protected Expr importExpr(Expr expr) {
return expr.exportTo(exprManager, exportMapping);
}
/** export an expression from this prover's context into global context. */
protected Expr exportExpr(Expr expr) {
return expr.exportTo(creator.getEnv(), exportMapping);
}
@Override
public void push() {
Preconditions.checkState(!closed);
setChanged();
assertedFormulas.push(new ArrayList<>());
if (incremental) {
smtEngine.push();
}
}
@Override
public void pop() {
Preconditions.checkState(!closed);
setChanged();
assertedFormulas.pop();
Preconditions.checkState(!assertedFormulas.isEmpty(), "initial level must remain until close");
if (incremental) {
smtEngine.pop();
}
}
@Override
public int size() {
Preconditions.checkState(!closed);
return assertedFormulas.size() - 1;
}
@Override
public @Nullable Void addConstraint(BooleanFormula pF) throws InterruptedException {
Preconditions.checkState(!closed);
setChanged();
Expr exp = creator.extractInfo(pF);
assertedFormulas.peek().add(exp);
if (incremental) {
smtEngine.assertFormula(importExpr(exp));
}
return null;
}
@SuppressWarnings("resource")
@Override
public CVC4Model getModel() {
Preconditions.checkState(!closed);
Preconditions.checkState(!changedSinceLastSatQuery);
checkGenerateModels();
// special case for CVC4: Models are not permanent and need to be closed
// before any change is applied to the prover stack. So, we register the Model as Evaluator.
return registerEvaluator(new CVC4Model(this, creator, smtEngine, getAssertedExpressions()));
}
@Override
public Evaluator getEvaluator() {
Preconditions.checkState(!closed);
checkGenerateModels();
return getEvaluatorWithoutChecks();
}
@SuppressWarnings("resource")
@Override
protected Evaluator getEvaluatorWithoutChecks() {
return registerEvaluator(new CVC4Evaluator(this, creator, smtEngine));
}
private void setChanged() {
closeAllEvaluators();
if (!changedSinceLastSatQuery) {
changedSinceLastSatQuery = true;
if (!incremental) {
// create a new clean smtEngine
smtEngine = new SmtEngine(exprManager);
}
}
}
@Override
public ImmutableList<ValueAssignment> getModelAssignments() throws SolverException {
Preconditions.checkState(!closed);
Preconditions.checkState(!changedSinceLastSatQuery);
return super.getModelAssignments();
}
@Override
@SuppressWarnings("try")
public boolean isUnsat() throws InterruptedException, SolverException {
Preconditions.checkState(!closed);
closeAllEvaluators();
changedSinceLastSatQuery = false;
if (!incremental) {
for (Expr expr : getAssertedExpressions()) {
smtEngine.assertFormula(importExpr(expr));
}
}
Result result;
try (ShutdownHook hook = new ShutdownHook(shutdownNotifier, smtEngine::interrupt)) {
shutdownNotifier.shutdownIfNecessary();
result = smtEngine.checkSat();
}
shutdownNotifier.shutdownIfNecessary();
return convertSatResult(result);
}
private boolean convertSatResult(Result result) throws InterruptedException, SolverException {
if (result.isUnknown()) {
if (result.whyUnknown().equals(Result.UnknownExplanation.INTERRUPTED)) {
throw new InterruptedException();
} else {
throw new SolverException("CVC4 returned null or unknown on sat check (" + result + ")");
}
}
if (result.isSat() == Result.Sat.SAT) {
return false;
} else if (result.isSat() == Result.Sat.UNSAT) {
return true;
} else {
throw new SolverException("CVC4 returned unknown on sat check");
}
}
@Override
public List<BooleanFormula> getUnsatCore() {
Preconditions.checkState(!closed);
checkGenerateUnsatCores();
Preconditions.checkState(!changedSinceLastSatQuery);
List<BooleanFormula> converted = new ArrayList<>();
for (Expr aCore : smtEngine.getUnsatCore()) {
converted.add(creator.encapsulateBoolean(exportExpr(aCore)));
}
return converted;
}
@Override
public boolean isUnsatWithAssumptions(Collection<BooleanFormula> pAssumptions)
throws SolverException, InterruptedException {
throw new UnsupportedOperationException();
}
@Override
public Optional<List<BooleanFormula>> unsatCoreOverAssumptions(
Collection<BooleanFormula> pAssumptions) throws SolverException, InterruptedException {
throw new UnsupportedOperationException();
}
protected Collection<Expr> getAssertedExpressions() {
List<Expr> result = new ArrayList<>();
assertedFormulas.forEach(result::addAll);
return result;
}
@Override
public void close() {
if (!closed) {
assertedFormulas.clear();
exportMapping.delete();
// smtEngine.delete();
exprManager.delete();
closed = true;
}
super.close();
}
}
| 9,243 | 32.614545 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/CVC4UFManager.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.cvc4;
import edu.stanford.CVC4.Expr;
import edu.stanford.CVC4.ExprManager;
import edu.stanford.CVC4.Type;
import org.sosy_lab.java_smt.basicimpl.AbstractUFManager;
class CVC4UFManager extends AbstractUFManager<Expr, Expr, Type, ExprManager> {
CVC4UFManager(CVC4FormulaCreator pCreator) {
super(pCreator);
}
}
| 598 | 26.227273 | 78 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc4/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 CVC4 (based on Java Bindings generated with SWIG). */
package org.sosy_lab.java_smt.solvers.cvc4;
| 370 | 32.727273 | 85 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5AbstractProver.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 io.github.cvc5.CVC5ApiException;
import io.github.cvc5.Result;
import io.github.cvc5.Solver;
import io.github.cvc5.Term;
import io.github.cvc5.UnknownExplanation;
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.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.Evaluator;
import org.sosy_lab.java_smt.api.FormulaManager;
import org.sosy_lab.java_smt.api.Model.ValueAssignment;
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;
public class CVC5AbstractProver<T> extends AbstractProverWithAllSat<T> {
private final FormulaManager mgr;
protected final CVC5FormulaCreator creator;
protected final Solver solver;
private boolean changedSinceLastSatQuery = false;
/** Tracks formulas on the stack, needed for model generation. */
protected final Deque<List<Term>> assertedFormulas = new ArrayDeque<>();
// TODO: does CVC5 support separation logic in incremental mode?
protected final boolean incremental;
protected CVC5AbstractProver(
CVC5FormulaCreator pFormulaCreator,
ShutdownNotifier pShutdownNotifier,
@SuppressWarnings("unused") int randomSeed,
Set<ProverOptions> pOptions,
FormulaManager pMgr) {
super(pOptions, pMgr.getBooleanFormulaManager(), pShutdownNotifier);
mgr = pMgr;
creator = pFormulaCreator;
incremental = !enableSL;
assertedFormulas.push(new ArrayList<>()); // create initial level
solver = new Solver();
setSolverOptions(randomSeed, pOptions);
}
private void setSolverOptions(int randomSeed, Set<ProverOptions> pOptions) {
if (incremental) {
solver.setOption("incremental", "true");
}
if (pOptions.contains(ProverOptions.GENERATE_MODELS)) {
solver.setOption("produce-models", "true");
}
if (pOptions.contains(ProverOptions.GENERATE_UNSAT_CORE)) {
solver.setOption("produce-unsat-cores", "true");
}
solver.setOption("produce-assertions", "true");
solver.setOption("dump-models", "true");
solver.setOption("output-language", "smt2");
solver.setOption("seed", String.valueOf(randomSeed));
// Set Strings option to enable all String features (such as lessOrEquals)
solver.setOption("strings-exp", "true");
// Enable more complete quantifier solving (for more info see CVC5QuantifiedFormulaManager)
solver.setOption("full-saturate-quant", "true");
}
@Override
public void push() {
Preconditions.checkState(!closed);
setChanged();
assertedFormulas.push(new ArrayList<>());
if (incremental) {
try {
solver.push();
} catch (CVC5ApiException e) {
throw new IllegalStateException(
"You tried to use push() on an CVC5 assertion stack illegally.", e);
}
}
}
@Override
public void pop() {
Preconditions.checkState(!closed);
setChanged();
assertedFormulas.pop();
Preconditions.checkState(!assertedFormulas.isEmpty(), "initial level must remain until close");
if (incremental) {
try {
solver.pop();
} catch (CVC5ApiException e) {
throw new IllegalStateException(
"You tried to use pop() on an CVC5 assertion stack illegally.", e);
}
}
}
@Override
public @Nullable T addConstraint(BooleanFormula pF) throws InterruptedException {
Preconditions.checkState(!closed);
setChanged();
Term exp = creator.extractInfo(pF);
assertedFormulas.peek().add(exp);
if (incremental) {
solver.assertFormula(exp);
}
return null;
}
@SuppressWarnings("resource")
@Override
public CVC5Model getModel() {
Preconditions.checkState(!closed);
Preconditions.checkState(!changedSinceLastSatQuery);
checkGenerateModels();
// special case for CVC5: Models are not permanent and need to be closed
// before any change is applied to the prover stack. So, we register the Model as Evaluator.
return registerEvaluator(new CVC5Model(this, mgr, creator, getAssertedExpressions()));
}
@Override
public Evaluator getEvaluator() {
Preconditions.checkState(!closed);
checkGenerateModels();
return getEvaluatorWithoutChecks();
}
@SuppressWarnings("resource")
@Override
protected Evaluator getEvaluatorWithoutChecks() {
return registerEvaluator(new CVC5Evaluator(this, creator));
}
protected void setChanged() {
if (!changedSinceLastSatQuery) {
changedSinceLastSatQuery = true;
closeAllEvaluators();
}
}
@Override
public ImmutableList<ValueAssignment> getModelAssignments() throws SolverException {
Preconditions.checkState(!closed);
Preconditions.checkState(!changedSinceLastSatQuery);
return super.getModelAssignments();
}
@Override
@SuppressWarnings("try")
public boolean isUnsat() throws InterruptedException, SolverException {
Preconditions.checkState(!closed);
closeAllEvaluators();
changedSinceLastSatQuery = false;
if (!incremental) {
getAssertedExpressions().forEach(solver::assertFormula);
}
/* Shutdown currently not possible in CVC5. */
Result result = solver.checkSat();
shutdownNotifier.shutdownIfNecessary();
return convertSatResult(result);
}
private boolean convertSatResult(Result result) throws InterruptedException, SolverException {
if (result.isUnknown()) {
if (result.getUnknownExplanation().equals(UnknownExplanation.INTERRUPTED)) {
throw new InterruptedException();
} else {
throw new SolverException(
"CVC5 returned null or unknown on sat check. Exact result: " + result + ".");
}
}
return result.isUnsat();
}
@Override
public List<BooleanFormula> getUnsatCore() {
Preconditions.checkState(!closed);
checkGenerateUnsatCores();
Preconditions.checkState(!changedSinceLastSatQuery);
List<BooleanFormula> converted = new ArrayList<>();
for (Term aCore : solver.getUnsatCore()) {
converted.add(creator.encapsulateBoolean(aCore));
}
return converted;
}
@Override
public boolean isUnsatWithAssumptions(Collection<BooleanFormula> pAssumptions)
throws SolverException, InterruptedException {
throw new UnsupportedOperationException();
}
@Override
public Optional<List<BooleanFormula>> unsatCoreOverAssumptions(
Collection<BooleanFormula> pAssumptions) throws SolverException, InterruptedException {
throw new UnsupportedOperationException();
}
protected Collection<Term> getAssertedExpressions() {
List<Term> result = new ArrayList<>();
assertedFormulas.forEach(result::addAll);
return result;
}
@Override
public void close() {
if (!closed) {
assertedFormulas.clear();
solver.deletePointer();
closed = true;
}
super.close();
}
@Override
public int size() {
Preconditions.checkState(!closed);
return assertedFormulas.size() - 1;
}
}
| 7,616 | 30.345679 | 99 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5ArrayFormulaManager.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.api.Formula;
import org.sosy_lab.java_smt.api.FormulaType;
import org.sosy_lab.java_smt.api.FormulaType.ArrayFormulaType;
import org.sosy_lab.java_smt.basicimpl.AbstractArrayFormulaManager;
public class CVC5ArrayFormulaManager extends AbstractArrayFormulaManager<Term, Sort, Solver, Term> {
private final Solver solver;
public CVC5ArrayFormulaManager(CVC5FormulaCreator pFormulaCreator) {
super(pFormulaCreator);
solver = pFormulaCreator.getEnv();
}
@Override
protected Term select(Term pArray, Term pIndex) {
return solver.mkTerm(Kind.SELECT, pArray, pIndex);
}
@Override
protected Term store(Term pArray, Term pIndex, Term pValue) {
return solver.mkTerm(Kind.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 cvc5ArrayType = toSolverType(arrayFormulaType);
return getFormulaCreator().makeVariable(cvc5ArrayType, pName);
}
@Override
protected Term equivalence(Term pArray1, Term pArray2) {
return solver.mkTerm(Kind.EQUAL, pArray1, pArray2);
}
}
| 1,761 | 31.62963 | 100 | java |
java-smt | java-smt-master/src/org/sosy_lab/java_smt/solvers/cvc5/CVC5BitvectorFormulaManager.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.Op;
import io.github.cvc5.Solver;
import io.github.cvc5.Sort;
import io.github.cvc5.Term;
import java.math.BigInteger;
import java.util.List;
import org.sosy_lab.java_smt.basicimpl.AbstractBitvectorFormulaManager;
public class CVC5BitvectorFormulaManager
extends AbstractBitvectorFormulaManager<Term, Sort, Solver, Term> {
private final Solver solver;
protected CVC5BitvectorFormulaManager(
CVC5FormulaCreator pCreator, CVC5BooleanFormulaManager pBmgr) {
super(pCreator, pBmgr);
solver = pCreator.getEnv();
}
@Override
protected Term concat(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.BITVECTOR_CONCAT, pParam1, pParam2);
}
@Override
protected Term extract(Term pParam1, int pMsb, int pLsb) {
Op ext;
try {
if (pMsb < pLsb || pMsb >= pParam1.getSort().getBitVectorSize() || pLsb < 0 || pMsb < 0) {
ext = solver.mkOp(Kind.BITVECTOR_EXTRACT, 0, 0);
} else {
ext = solver.mkOp(Kind.BITVECTOR_EXTRACT, pMsb, pLsb);
}
return solver.mkTerm(ext, pParam1);
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"You tried creating a invalid bitvector extract from bit "
+ pMsb
+ " to bit "
+ pLsb
+ " in term "
+ pParam1
+ ".",
e);
}
}
@Override
protected Term extend(Term pParam1, int pExtensionBits, boolean signed) {
final Op op;
try {
if (signed) {
op = solver.mkOp(Kind.BITVECTOR_SIGN_EXTEND, pExtensionBits);
} else {
op = solver.mkOp(Kind.BITVECTOR_ZERO_EXTEND, pExtensionBits);
}
return solver.mkTerm(op, pParam1);
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"You tried creating a invalid bitvector extend with term "
+ pParam1
+ " and t "
+ pExtensionBits
+ " extension bits.",
e);
}
}
@Override
protected Term makeBitvectorImpl(int pLength, BigInteger pI) {
pI = transformValueToRange(pLength, pI);
try {
// Use String conversion as it can hold more values
return solver.mkBitVector(pLength, pI.toString(), 10);
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"You tried creating a invalid bitvector with length "
+ pLength
+ " and value "
+ pI
+ ".",
e);
}
}
@Override
protected Term makeVariableImpl(int length, String varName) {
try {
Sort type = solver.mkBitVectorSort(length);
return getFormulaCreator().makeVariable(type, varName);
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"You tried creating a invalid bitvector variable with length "
+ length
+ " and name "
+ varName
+ ".",
e);
}
}
@Override
protected Term shiftRight(Term pParam1, Term pParam2, boolean signed) {
if (signed) {
return solver.mkTerm(Kind.BITVECTOR_ASHR, pParam1, pParam2);
} else {
return solver.mkTerm(Kind.BITVECTOR_LSHR, pParam1, pParam2);
}
}
@Override
protected Term shiftLeft(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.BITVECTOR_SHL, pParam1, pParam2);
}
@Override
protected Term not(Term pParam1) {
return solver.mkTerm(Kind.BITVECTOR_NOT, pParam1);
}
@Override
protected Term and(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.BITVECTOR_AND, pParam1, pParam2);
}
@Override
protected Term or(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.BITVECTOR_OR, pParam1, pParam2);
}
@Override
protected Term xor(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.BITVECTOR_XOR, pParam1, pParam2);
}
@Override
protected Term negate(Term pParam1) {
return solver.mkTerm(Kind.BITVECTOR_NEG, pParam1);
}
@Override
protected Term add(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.BITVECTOR_ADD, pParam1, pParam2);
}
@Override
protected Term subtract(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.BITVECTOR_SUB, pParam1, pParam2);
}
@Override
protected Term divide(Term pParam1, Term pParam2, boolean signed) {
if (signed) {
return solver.mkTerm(Kind.BITVECTOR_SDIV, pParam1, pParam2);
} else {
return solver.mkTerm(Kind.BITVECTOR_UDIV, pParam1, pParam2);
}
}
@Override
protected Term modulo(Term pParam1, Term pParam2, boolean signed) {
if (signed) {
return solver.mkTerm(Kind.BITVECTOR_SREM, pParam1, pParam2);
} else {
return solver.mkTerm(Kind.BITVECTOR_UREM, pParam1, pParam2);
}
}
@Override
protected Term multiply(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.BITVECTOR_MULT, pParam1, pParam2);
}
@Override
protected Term equal(Term pParam1, Term pParam2) {
return solver.mkTerm(Kind.EQUAL, pParam1, pParam2);
}
@Override
protected Term lessThan(Term pParam1, Term pParam2, boolean signed) {
if (signed) {
return solver.mkTerm(Kind.BITVECTOR_SLT, pParam1, pParam2);
} else {
return solver.mkTerm(Kind.BITVECTOR_ULT, pParam1, pParam2);
}
}
@Override
protected Term lessOrEquals(Term pParam1, Term pParam2, boolean signed) {
if (signed) {
return solver.mkTerm(Kind.BITVECTOR_SLE, pParam1, pParam2);
} else {
return solver.mkTerm(Kind.BITVECTOR_ULE, pParam1, pParam2);
}
}
@Override
protected Term greaterThan(Term pParam1, Term pParam2, boolean signed) {
if (signed) {
return solver.mkTerm(Kind.BITVECTOR_SGT, pParam1, pParam2);
} else {
return solver.mkTerm(Kind.BITVECTOR_UGT, pParam1, pParam2);
}
}
@Override
protected Term greaterOrEquals(Term pParam1, Term pParam2, boolean signed) {
if (signed) {
return solver.mkTerm(Kind.BITVECTOR_SGE, pParam1, pParam2);
} else {
return solver.mkTerm(Kind.BITVECTOR_UGE, pParam1, pParam2);
}
}
@Override
protected Term makeBitvectorImpl(int pLength, Term pParam1) {
try {
Op length = solver.mkOp(Kind.INT_TO_BITVECTOR, pLength);
return solver.mkTerm(length, pParam1);
} catch (CVC5ApiException e) {
throw new IllegalArgumentException(
"You tried creating a invalid bitvector out of a integer term "
+ pParam1
+ " with length "
+ pLength
+ ".",
e);
}
}
@Override
protected Term toIntegerFormulaImpl(Term pBv, boolean pSigned) {
Term intExpr = solver.mkTerm(Kind.BITVECTOR_TO_NAT, pBv);
// CVC5 returns unsigned int by default
if (pSigned && pBv.getSort().isBitVector()) {
// TODO check what is cheaper for the solver:
// checking the first BV-bit or computing max-int-value for the given size
final int size = Math.toIntExact(pBv.getSort().getBitVectorSize());
final BigInteger modulo = BigInteger.ONE.shiftLeft(size);
final BigInteger maxInt = BigInteger.ONE.shiftLeft(size - 1).subtract(BigInteger.ONE);
final Term moduloExpr = solver.mkInteger(modulo.longValue());
final Term maxIntExpr = solver.mkInteger(maxInt.longValue());
intExpr =
solver.mkTerm(
Kind.ITE,
solver.mkTerm(Kind.GT, intExpr, maxIntExpr),
solver.mkTerm(Kind.SUB, intExpr, moduloExpr),
intExpr);
}
return intExpr;
}
@Override
protected Term distinctImpl(List<Term> pParam) {
return solver.mkTerm(Kind.DISTINCT, pParam.toArray(new Term[0]));
}
}
| 8,047 | 28.265455 | 96 | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.