Examples with Pair com.sri.ai.util.base.Pair used on opensource projects

Example 11 with Pair

use of com.sri.ai.util.base.Pair in project aic-expresso by aic-sri-international.

the class TupleQuantifierSimplifier method update.

private static Pair<IndexExpressionsSet, Expression> update(Expression expression, Map<Expression, Expression> indexToTypeMap, Map<Expression, Expression> indexToTupleOfVars, Context context) {
    List<Expression> indexExpressions = new ArrayList<>();
    Expression substitutedExpression = expression;
    for (Map.Entry<Expression, Expression> entry : indexToTypeMap.entrySet()) {
        Expression entryIndex = entry.getKey();
        Expression entryType = entry.getValue();
        Expression tupleVars = indexToTupleOfVars.get(entryIndex);
        if (tupleVars != null) {
            substitutedExpression = substitutedExpression.replaceAllOccurrences(entryIndex, tupleVars, context);
            for (int i = 0; i < entryType.numberOfArguments(); i++) {
                indexExpressions.add(Expressions.apply(FunctorConstants.IN, tupleVars.get(i), entryType.get(i)));
            }
        } else {
            if (entryType == null) {
                indexExpressions.add(entryIndex);
            } else {
                indexExpressions.add(Expressions.apply(FunctorConstants.IN, entryIndex, entryType));
            }
        }
    }
    ExtensionalIndexExpressionsSet indexExpressionsSet = new ExtensionalIndexExpressionsSet(indexExpressions);
    return new Pair<>(indexExpressionsSet, substitutedExpression);
}

Example 12 with Pair

use of com.sri.ai.util.base.Pair in project aic-expresso by aic-sri-international.

the class TupleValuedFreeVariablesSimplifier method createReverseLookupMap.

private static Map<Expression, Pair<Expression, Integer>> createReverseLookupMap(Map<Expression, List<Pair<Expression, Integer>>> freeVariableComponentsMap) {
    Map<Expression, Pair<Expression, Integer>> result = new LinkedHashMap<>();
    for (Map.Entry<Expression, List<Pair<Expression, Integer>>> freeVariableComponents : freeVariableComponentsMap.entrySet()) {
        Expression freeVariable = freeVariableComponents.getKey();
        for (Pair<Expression, Integer> component : freeVariableComponents.getValue()) {
            Expression componentVariable = component.first;
            Integer componentIndex = component.second;
            result.put(componentVariable, new Pair<>(freeVariable, componentIndex));
        }
    }
    return result;
}

Example 13 with Pair

use of com.sri.ai.util.base.Pair in project aic-expresso by aic-sri-international.

the class InversionSimplifier method getIndexAndFunctionType.

private static Pair<Expression, FunctionType> getIndexAndFunctionType(Expression functionOnIntensionalSet, Context context) {
    IndexExpressionsSet indexExpressionsSet = getIndexExpressions(functionOnIntensionalSet);
    List<Expression> indices = IndexExpressions.getIndices(indexExpressionsSet);
    if (indices.size() != 1) {
        throw new UnsupportedOperationException("Currently only support singular indices");
    }
    Expression index = indices.get(0);
    Context intensionalSetContext = context.extendWith(indexExpressionsSet);
    Type type = GrinderUtil.getTypeOfExpression(index, intensionalSetContext);
    FunctionType functionType = null;
    if (type instanceof FunctionType) {
        functionType = (FunctionType) type;
    }
    Pair<Expression, FunctionType> result = new Pair<>(index, functionType);
    return result;
}

Example 14 with Pair

use of com.sri.ai.util.base.Pair in project aic-expresso by aic-sri-international.

the class TupleValuedFreeVariablesSimplifier method constructComponentTuple.

private static Expression constructComponentTuple(List<Pair<Expression, Integer>> replacementComponents) {
    List<Expression> elements = replacementComponents.stream().map(pair -> pair.first).collect(Collectors.toList());
    Expression result = Expressions.makeTuple(elements);
    return result;
}

Example 15 with Pair

use of com.sri.ai.util.base.Pair in project aic-expresso by aic-sri-international.

the class TupleValuedFreeVariablesSimplifier method extendContextWithComponentVariables.

private static Context extendContextWithComponentVariables(Context context, Map<Expression, TupleType> freeVariablesOfTupleType, Map<Expression, List<Pair<Expression, Integer>>> freeVariableComponentsMap) {
    Map<String, String> mapFromSymbolNameToTypeName = new LinkedHashMap<>();
    Set<Type> componentTypes = new LinkedHashSet<>();
    for (Map.Entry<Expression, TupleType> freeVariableOfTupleType : freeVariablesOfTupleType.entrySet()) {
        Expression freeVariable = freeVariableOfTupleType.getKey();
        TupleType freeVariableTupleType = freeVariableOfTupleType.getValue();
        componentTypes.addAll(freeVariableTupleType.getElementTypes());
        List<Pair<Expression, Integer>> components = freeVariableComponentsMap.get(freeVariable);
        for (Pair<Expression, Integer> freeVariableComponent : components) {
            Expression freeVariableComponentVar = freeVariableComponent.first;
            Type freeVariableComponentType = freeVariableTupleType.getElementTypes().get(freeVariableComponent.second - 1);
            mapFromSymbolNameToTypeName.put(freeVariableComponentVar.toString(), freeVariableComponentType.getName());
        }
    }
    Context result = (Context) GrinderUtil.extendRegistryWith(mapFromSymbolNameToTypeName, componentTypes, context);
    return result;
}