Examples with And com.sri.ai.grinder.library.boole.And used on opensource projects

Example 1 with And

use of com.sri.ai.grinder.library.boole.And in project aic-expresso by aic-sri-international.

the class Expressions method standardizeApart.

/**
 * Given a symbol, a predicate indicating what symbols are already defined in some situation,
 * and an expression possibly containing the symbol,
 * prime the symbol until it is unique,
 * and return the new symbol and the result of replacing the old symbol by the new in the expression containing it.
 * @param symbol
 * @param alreadyDefined
 * @param containingSymbol
 * @return the new symbol and the result of replacing the old symbol by the new in the expression containing it.
 */
public static PairOf<Expression> standardizeApart(Symbol symbol, Predicate<Expression> alreadyDefined, Expression containingSymbol) {
    Expression newSymbol = symbol;
    while (alreadyDefined.apply(newSymbol)) {
        newSymbol = primedUntilUnique(newSymbol, s -> !alreadyDefined.apply(s));
    }
    Expression newExpressionContainingSymbol = containingSymbol.replaceSymbol(symbol, newSymbol, null);
    PairOf<Expression> result = pairOf(newSymbol, newExpressionContainingSymbol);
    return result;
}

Example 2 with And

use of com.sri.ai.grinder.library.boole.And in project aic-expresso by aic-sri-international.

the class Expressions method standardizeApart.

/**
 * Given a symbol, a predicate indicating what symbols are already defined in some situation,
 * and an expression possibly containing the symbol,
 * prime the symbol until it is unique,
 * and return the new symbol and the result of replacing the old symbol by the new in the expression containing it.
 * @param symbol
 * @param alreadyDefined
 * @param containingSymbol
 * @return the new symbol and the result of replacing the old symbol by the new in the expression containing it.
 */
public static PairOf<Expression> standardizeApart(Expression symbol, Predicate<Expression> alreadyDefined, Expression containingSymbol) {
    Expression newSymbol = symbol;
    while (alreadyDefined.apply(newSymbol)) {
        newSymbol = primedUntilUnique(newSymbol, s -> !alreadyDefined.apply(s));
    }
    Expression newExpressionContainingSymbol = containingSymbol.replaceSymbol(symbol, newSymbol, null);
    PairOf<Expression> result = pairOf(newSymbol, newExpressionContainingSymbol);
    return result;
}

Example 3 with And

use of com.sri.ai.grinder.library.boole.And in project aic-expresso by aic-sri-international.

the class SGDPLLTTester method testCompleteMultiVariableConstraints.

/**
 * Given a theory and a number <code>n</code> of multi-variable constraint tests,
 * generates <code>n</code> formulas in the theory
 * and see if those detected as unsatisfiable by the corresponding solver
 * are indeed unsatisfiable (checked by brute force).
 * Throws an {@link Error} with the failure description if a test fails.
 * @param theoryTestingSupport
 * @param numberOfTests
 * @param maxNumberOfLiterals
 * @param outputCount
 */
public static void testCompleteMultiVariableConstraints(boolean testAgainstBruteForce, TheoryTestingSupport theoryTestingSupport, long numberOfTests, int maxNumberOfLiterals, boolean outputCount) {
    Context context = theoryTestingSupport.makeContextWithTestingInformation();
    NullaryFunction<Constraint> makeInitialConstraint = () -> context;
    Function<Constraint, Expression> makeRandomLiteral = c -> theoryTestingSupport.makeRandomLiteral(context);
    // CompleteMultiVariableContext is complete
    TestRunner tester = SGDPLLTTester::testCompleteSatisfiability;
    runTesterGivenOnSuccessiveConjunctionsOfLiterals("complete satisfiability", tester, numberOfTests, maxNumberOfLiterals, testAgainstBruteForce, theoryTestingSupport, makeInitialConstraint, makeRandomLiteral, outputCount, context);
}

Example 4 with And

use of com.sri.ai.grinder.library.boole.And in project aic-expresso by aic-sri-international.

the class SGDPLLTTester method testSingleVariableConstraints.

/**
 * Given a theory and a number <code>n</code> of single-variable constraint tests,
 * generates <code>n</code> formulas in the theory
 * and see if those detected as unsatisfiable by the corresponding solver
 * are indeed unsatisfiable (checked by brute force).
 * Throws an {@link Error} with the failure description if a test fails.
 * @param theoryTestingSupport
 * @param numberOfTests
 * @param maxNumberOfLiterals
 * @param outputCount
 */
public static void testSingleVariableConstraints(boolean testAgainstBruteForce, TheoryTestingSupport theoryTestingSupport, long numberOfTests, int maxNumberOfLiterals, boolean outputCount) {
    Context context = theoryTestingSupport.makeContextWithTestingInformation();
    NullaryFunction<Constraint> makeInitialConstraint = () -> theoryTestingSupport.getTheory().makeSingleVariableConstraint(parse(theoryTestingSupport.pickTestingVariableAtRandom()), context);
    Function<Constraint, Expression> makeRandomLiteral = c -> theoryTestingSupport.makeRandomLiteralOn(((SingleVariableConstraint) c).getVariable().toString(), context);
    boolean isComplete = theoryTestingSupport.getTheory().singleVariableConstraintIsCompleteWithRespectToItsVariable();
    TestRunner tester = isComplete ? SGDPLLTTester::testCompleteSatisfiability : SGDPLLTTester::testIncompleteSatisfiability;
    String problemName = (isComplete ? "complete" : "incomplete") + " satisfiability for single-variable constraints";
    runTesterGivenOnSuccessiveConjunctionsOfLiterals(problemName, tester, numberOfTests, maxNumberOfLiterals, testAgainstBruteForce, theoryTestingSupport, makeInitialConstraint, makeRandomLiteral, outputCount, context);
}

Example 5 with And

use of com.sri.ai.grinder.library.boole.And in project aic-expresso by aic-sri-international.

the class SGDPLLTTester method runGroupProblemSolvingTestGivenConstraintAndProblem.

/**
 * @param problem
 * @param indices
 * @param constraint
 * @param body
 * @param testAgainstBruteForce
 * @param theoryTestingSupport
 * @param context
 * @throws Error
 */
public static void runGroupProblemSolvingTestGivenConstraintAndProblem(Expression problem, Collection<Expression> indices, Constraint constraint, Expression body, boolean testAgainstBruteForce, TheoryTestingSupport theoryTestingSupport, Context context) throws Error {
    Theory theory = theoryTestingSupport.getTheory();
    Collection<? extends Expression> freeVariables = getFreeVariableMinusIndices(indices, constraint, body, context);
    String problemDescription = problem.toString();
    output(problemDescription);
    Simplifier symbolicInterpreter = (e, c) -> theory.evaluate(e, c);
    long start = System.currentTimeMillis();
    Expression symbolicSolution = symbolicInterpreter.apply(problem, context);
    long time = System.currentTimeMillis() - start;
    output("Symbolic solution: " + symbolicSolution);
    output("Computed in " + time + " ms");
    if (Util.thereExists(new SubExpressionsDepthFirstIterator(symbolicSolution), e -> e instanceof QuantifiedExpression || Sets.isIntensionalSet(e))) {
        throw new Error("Symbolic solution is not quantifier-free: " + symbolicSolution);
    }
    if (testAgainstBruteForce) {
        BinaryFunction<BruteForceCommonInterpreter, Context, Expression> bruteForceSolutionGivenInterpreterAndContextWithAssignmentToOtherVariables = (i, c) -> i.apply(problem, c);
        testSymbolicVsBruteForceComputationForEachAssignment(theory, problemDescription, freeVariables, symbolicSolution, bruteForceSolutionGivenInterpreterAndContextWithAssignmentToOtherVariables, context);
    // A more elegant approach would be to create a "for all free variables : symbolic = problem" expression
    // and solve it by brute force instead of using testSymbolicVsBruteForceComputation
    // which replicates the brute force interpreter to some extent.
    // The reason we do not do this is simply due to the fact that the brute force interpreter would return "false"
    // in case of failure, without indicating which assignment failed, which is very useful for debugging.
    // If interpreters, and in fact the whole framework, provided proofs of its calculations,
    // then we could simply use the more elegant approach.
    } else {
        output("Skipping test againt brute-force.");
    }
}