use of com.sri.ai.expresso.api.QuantifiedExpression in project aic-expresso by aic-sri-international.
the class TupleQuantifierSimplifier method rewriteForAll.
private static Expression rewriteForAll(Expression quantifiedExpression, Map<Expression, Expression> indexToTypeMap, Map<Expression, Expression> indexToTupleOfVars, Context context) {
if (indexToTypeMap.size() > 1) {
throw new IllegalStateException("We have a Universal Quantifier with > 1 index : " + quantifiedExpression);
}
Pair<IndexExpressionsSet, Expression> updatePair = update(ForAll.getBody(quantifiedExpression), indexToTypeMap, indexToTupleOfVars, context);
Expression result = ForAll.make(updatePair.first, updatePair.second);
return result;
}
use of com.sri.ai.expresso.api.QuantifiedExpression in project aic-expresso by aic-sri-international.
the class TupleQuantifierSimplifier method rewriteThereExists.
private static Expression rewriteThereExists(Expression quantifiedExpression, Map<Expression, Expression> indexToTypeMap, Map<Expression, Expression> indexToTupleOfVars, Context context) {
if (indexToTypeMap.size() > 1) {
throw new IllegalStateException("We have an Existential Quantifier with > 1 index : " + quantifiedExpression);
}
Pair<IndexExpressionsSet, Expression> updatePair = update(ThereExists.getBody(quantifiedExpression), indexToTypeMap, indexToTupleOfVars, context);
Expression result = ThereExists.make(updatePair.first, updatePair.second);
return result;
}
use of com.sri.ai.expresso.api.QuantifiedExpression in project aic-praise by aic-sri-international.
the class HOGMModelValidator method getIndexToTypeMap.
private Map<Expression, Expression> getIndexToTypeMap(QuantifiedExpression quantifiedExpression) {
IndexExpressionsSet indexExpressionSet = quantifiedExpression.getIndexExpressions();
Map<Expression, Expression> indexToTypeMap = getIndexToTypeMapWithDefaultNull(indexExpressionSet);
return indexToTypeMap;
}
use of com.sri.ai.expresso.api.QuantifiedExpression in project aic-expresso by aic-sri-international.
the class SGDPLLTTester method runModelCountingTestForSingleVariableConstraint.
private static void runModelCountingTestForSingleVariableConstraint(Expression variable, Collection<Expression> literals, Constraint constraint, boolean testAgainstBruteForce, Theory theory, Context context) {
Expression literalsConjunction = And.make(literals);
String problemDescription = "model counting of " + literalsConjunction + " for variable " + variable;
output("Problem: " + problemDescription);
Simplifier symbolicSolver = (e, p) -> computeModelCountBySolver((SingleVariableConstraint) e, p);
SingleVariableConstraint singleVariableConstraint = (SingleVariableConstraint) constraint;
Expression symbolicSolution = symbolicSolver.apply(singleVariableConstraint, context);
if (Util.thereExists(new SubExpressionsDepthFirstIterator(symbolicSolution), e -> e instanceof QuantifiedExpression || Sets.isIntensionalSet(e))) {
throw new Error("Symbolic solution is not quantifier-free: " + symbolicSolution);
}
output("Symbolic result: " + symbolicSolution);
if (testAgainstBruteForce) {
if (singleVariableConstraint.isContradiction()) {
if (!symbolicSolution.equals(ZERO)) {
throw new Error("Constraint is contradiction, but symbolic solver does not produce 0, but instead " + symbolicSolution);
}
} else {
Expression testingVariable = singleVariableConstraint.getVariable();
Set<Expression> allVariables = getVariableReferences(singleVariableConstraint, context);
Collection<Expression> otherVariables = removeFromSetNonDestructively(allVariables, v -> v.equals(testingVariable));
BinaryFunction<BruteForceCommonInterpreter, Context, Expression> fromInterpreterAndContextWithAssignmentToOtherVariablesToBruteForceSolution = (interpreter, contextWithAssignmentToOtherVariables) -> bruteForceModelCounterForVariableGivenInterpreterAndAssignmentToOtherVariables(variable, literalsConjunction, interpreter, theory, contextWithAssignmentToOtherVariables);
testSymbolicVsBruteForceComputationForEachAssignment(theory, problemDescription, otherVariables, symbolicSolution, fromInterpreterAndContextWithAssignmentToOtherVariablesToBruteForceSolution, context);
}
} else {
output("Skipping test againt brute-force.");
}
}
use of com.sri.ai.expresso.api.QuantifiedExpression in project aic-expresso by aic-sri-international.
the class SetOfArgumentTuplesForFunctionOccurringInExpression method computeUnionArgs.
private static void computeUnionArgs(List<Expression> unionArgs, Predicate<Expression> isF, FunctionType fType, Predicate<Expression> isFApplication, Expression e) {
// if E does not contain ƒ, oc<sub>ƒ</sub>[E] is ∅
if (!containsF(e, isF)) {
unionArgs.add(Sets.EMPTY_SET);
} else // if E is ƒ(t) for t a tuple, oc<sub>ƒ</sub>[E] is {t}
if (isFApplication.apply(e)) {
Expression tupleT = Expressions.makeTuple(e.getArguments());
Expression setT = ExtensionalSets.makeUniSet(tupleT);
unionArgs.add(setT);
} else // if E is ƒ, oc<sub>ƒ</sub>[E] is Α
if (isF.apply(e)) {
List<Expression> domainTypes = new ArrayList<>();
for (Type domainType : fType.getArgumentTypes()) {
domainTypes.add(Expressions.parse(domainType.getName()));
}
Expression tupleT = Expressions.makeTuple(domainTypes);
Expression setT = ExtensionalSets.makeUniSet(tupleT);
unionArgs.add(setT);
} else // if E is g(E′) for g a function symbol distinct from ƒ and t a k-tuple of expressions
if (Expressions.isFunctionApplicationWithArguments(e)) {
// if g(E′) is if C the E<sub>1</sub> else E<sub>2</sub> and C does not contain ƒ
if (IfThenElse.isIfThenElse(e) && !containsF(IfThenElse.condition(e), isF)) {
// then oc<sub>ƒ</sub>[E] is<br>
// if C then oc<sub>ƒ</sub>[E<sub>1</sub>] else oc<sub>ƒ</sub>[E<sub>2</sub>]
Expression e1 = IfThenElse.thenBranch(e);
List<Expression> thenUnionArgs = new ArrayList<>();
computeUnionArgs(thenUnionArgs, isF, fType, isFApplication, e1);
Expression thenBranch = makeUnion(thenUnionArgs);
Expression e2 = IfThenElse.elseBranch(e);
List<Expression> elseUnionArgs = new ArrayList<>();
computeUnionArgs(elseUnionArgs, isF, fType, isFApplication, e2);
Expression elseBranch = makeUnion(elseUnionArgs);
Expression ifThenElse = IfThenElse.make(IfThenElse.condition(e), thenBranch, elseBranch);
unionArgs.add(ifThenElse);
} else {
// oc<sub>ƒ</sub>[t<sub>1</sub>] ∪ … ∪ oc<sub>ƒ</sub>[t<sub>k</sub>]
for (Expression t : e.getArguments()) {
computeUnionArgs(unionArgs, isF, fType, isFApplication, t);
}
}
} else // quantified expression,
if (isArbitraryQuantifier(e) && !containsF(getQuantifierCondition(e), isF)) {
// then oc<sub>ƒ</sub>[E] is<br>
// ⋃<sub>x:C</sub>oc<sub>ƒ</sub>[E′]
QuantifiedExpression q = (QuantifiedExpression) e;
IndexExpressionsSet x = q.getIndexExpressions();
Expression c = getQuantifierCondition(e);
Expression ePrime = getQuantifiedExpression(q);
List<Expression> ePrimeUnionArgs = new ArrayList<>();
computeUnionArgs(ePrimeUnionArgs, isF, fType, isFApplication, ePrime);
Expression ocfOfEPrime = makeUnion(ePrimeUnionArgs);
Expression intensionalMultiSet = IntensionalSet.intensionalMultiSet(x, ocfOfEPrime, c);
Expression intensionalUnion = Expressions.apply(FunctorConstants.INTENSIONAL_UNION, intensionalMultiSet);
unionArgs.add(intensionalUnion);
} else // quantified expression,
if (isArbitraryQuantifier(e)) {
// then oc<sub>ƒ</sub>[E] is<br>
// ⋃<sub>x</sub>(oc<sub>ƒ</sub>[C] ∪ oc<sub>ƒ</sub>[E′])
QuantifiedExpression q = (QuantifiedExpression) e;
IndexExpressionsSet x = q.getIndexExpressions();
Expression c = getQuantifierCondition(e);
Expression ePrime = getQuantifiedExpression(q);
List<Expression> conditionUnionArgs = new ArrayList<>();
computeUnionArgs(conditionUnionArgs, isF, fType, isFApplication, c);
List<Expression> ePrimeUnionArgs = new ArrayList<>();
computeUnionArgs(ePrimeUnionArgs, isF, fType, isFApplication, ePrime);
List<Expression> combinedUnionArgs = new ArrayList<>();
combinedUnionArgs.addAll(conditionUnionArgs);
combinedUnionArgs.addAll(ePrimeUnionArgs);
Expression combinedUnion = makeUnion(combinedUnionArgs);
Expression intensionalMultiSet = IntensionalSet.intensionalMultiSet(x, combinedUnion, Expressions.TRUE);
Expression intensionalUnion = Expressions.apply(FunctorConstants.INTENSIONAL_UNION, intensionalMultiSet);
unionArgs.add(intensionalUnion);
} else {
throw new UnsupportedOperationException("Do not have logic for handling expression of the form: " + e);
}
}
Aggregations