Examples with Symbol com.sri.ai.expresso.api.Symbol used on opensource projects

Example 1 with Symbol

use of com.sri.ai.expresso.api.Symbol in project aic-expresso by aic-sri-international.

the class Context method extendWith.

/**
	 * Extends context with index expressions, taking into account that new contextual variables may collide with existing ones.
	 * In this case, it renames the incoming variables to unique identifiers and replaces them in the types of remaining
	 * index expressions. It also renames the variables in a given expressions supposed to be in their scope (for example,
	 * the head and condition of an intensionally defined set).
	 * Returns the new context and the index expressions and expression in scope after the renaming.
	 * @param indexExpressions
	 * @param expressionInScope
	 * @return the new context and the index expressions and expression in scope after the renaming
	 */
default default Triple<Context, ExtensionalIndexExpressionsSet, Expression> extendWith(ExtensionalIndexExpressionsSet indexExpressions, Expression expressionInScope) {
    Triple<Context, ExtensionalIndexExpressionsSet, Expression> result;
    if (thereExists(getIndices(indexExpressions), index -> this.containsSymbol(index))) {
        // OPTIMIZATION: only kick in this entire procedure when extending with symbol in the context (previous ones could have been dealt with normally).
        // the objects to be returned in the triple:
        Context newContext = this;
        ArrayList<Expression> newIndexExpressionsList = new ArrayList<>(indexExpressions.getList());
        Expression newExpressionInScope = expressionInScope;
        // Collects all existing symbols to be able to create unique symbols
        Set<Expression> alreadyDefined = Util.set();
        alreadyDefined.addAll(this.getSymbols());
        alreadyDefined.addAll(Expressions.freeSymbols(new DefaultTuple(newIndexExpressionsList), this));
        alreadyDefined.addAll(Expressions.freeSymbols(expressionInScope, this));
        Predicate<Expression> isAlreadyDefined = e -> alreadyDefined.contains(e);
        for (int i = 0; i != newIndexExpressionsList.size(); i++) {
            Expression indexExpression = newIndexExpressionsList.get(i);
            Symbol index = (Symbol) indexExpression.get(0);
            Expression type = indexExpression.get(1);
            PairOf<Expression> newIndexAndNewExpressionInScope = Expressions.standardizeApart(index, isAlreadyDefined, newExpressionInScope);
            Expression newIndex = newIndexAndNewExpressionInScope.first;
            newExpressionInScope = newIndexAndNewExpressionInScope.second;
            // type should not contain the index
            Expression newIndexExpression = apply(IN, newIndex, type);
            newIndexExpressionsList.set(i, newIndexExpression);
            alreadyDefined.add(newIndex);
            for (int j = i + 1; j != newIndexExpressionsList.size(); j++) {
                Expression anotherIndexExpression = newIndexExpressionsList.get(j);
                Expression anotherIndex = anotherIndexExpression.get(0);
                Expression anotherType = anotherIndexExpression.get(1);
                Expression newAnotherType = anotherType.replaceSymbol(index, newIndex, this);
                // anotherIndex is a symbols and does not contain index
                Expression newAnotherIndexExpression = apply(IN, anotherIndex, newAnotherType);
                newIndexExpressionsList.set(j, newAnotherIndexExpression);
            }
        }
        ExtensionalIndexExpressionsSet newIndexExpressions = new ExtensionalIndexExpressionsSet(newIndexExpressionsList);
        newContext = newContext.extendWith(newIndexExpressions);
        result = triple(newContext, newIndexExpressions, newExpressionInScope);
    } else {
        // no collision; usual extension and the expressions do not change.
        result = triple(extendWith(indexExpressions), indexExpressions, expressionInScope);
    }
    return result;
}

Example 2 with Symbol

use of com.sri.ai.expresso.api.Symbol 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 3 with Symbol

use of com.sri.ai.expresso.api.Symbol in project aic-praise by aic-sri-international.

the class ProceduralAttachmentExpressionFactor method computeInnerExpression.

@Override
protected Expression computeInnerExpression() {
    Variable variable = proceduralAttachment.getVariable();
    Object value = proceduralAttachment.getProcedureValue();
    Symbol valueExpression = DefaultSymbol.createSymbol(value);
    Type type = getVariableType(variable, getContext());
    Expression condition;
    if (value instanceof Double) {
        assertVariableIsOfRealType(variable, type, getContext());
        condition = makeIntervalFactorCondition(valueExpression);
    } else if (value instanceof Integer) {
        assertVariableIsOfIntegerType(variable, type, getContext());
        condition = makeEquality(valueExpression);
    } else if (value instanceof Boolean) {
        assertVariableIsOfBooleanType(variable, type, getContext());
        condition = makeBooleanCondition(valueExpression);
    } else {
        throw new Error("Procedural attachments must provide only Double or Integer objects, but procedure for " + proceduralAttachment.getVariable() + " provided " + proceduralAttachment.getProcedureValue() + " of type " + proceduralAttachment.getProcedureValue().getClass());
    }
    Expression result = IfThenElse.make(condition, Expressions.ONE, Expressions.ZERO);
    return result;
}

Example 4 with Symbol

use of com.sri.ai.expresso.api.Symbol in project aic-praise by aic-sri-international.

the class FromTableToExpressionFactorConverter method makeComparisonToAssignedValue.

private Expression makeComparisonToAssignedValue(Integer variableIndex, List<TableVariable> tableVariables, ArrayList<? extends Integer> assignment) {
    Integer assignedValue = assignment.get(variableIndex);
    Symbol assignedValueExpression = createSymbol(assignedValue);
    TableVariable tableVariable = tableVariables.get(variableIndex);
    Symbol variableExpression = makeVariableExpression(tableVariable);
    Expression result = Equality.make(variableExpression, assignedValueExpression);
    return result;
}

Example 5 with Symbol

use of com.sri.ai.expresso.api.Symbol in project aic-expresso by aic-sri-international.

the class IntegerInterval method sampleUniquelyNamedConstant.

@Override
public Expression sampleUniquelyNamedConstant(Random random) {
    myAssert(() -> boundsAreConstants(), () -> "Cannot sample uniquely named constant from integer interval that is infinite and/or defined by variables: " + getName());
    Symbol result = makeSymbol(new Rational(nonStrictLowerBound.intValue() + random.nextInt(nonStrictUpperBound.intValue() - nonStrictLowerBound.intValue() + 1)));
    return result;
}