Examples with Type com.google.api.expr.v1alpha1.Type used on opensource projects

Example 81 with Type

use of com.google.api.expr.v1alpha1.Type in project java-smt by sosy-lab.

the class CVC4FormulaCreator method visit.

@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() || type.isReal()) {
            return visitor.visitConstant(formula, f.getConstRational());
        } else if (type.isBitVector()) {
            // TODO is this correct?
            return visitor.visitConstant(formula, f.getConstBitVector().getValue());
        } 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());
        // 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));
    }
}

Example 82 with Type

use of com.google.api.expr.v1alpha1.Type in project java-smt by sosy-lab.

the class CVC4NativeAPITest method checkLIAUfsSat.

@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);
}

Example 83 with Type

use of com.google.api.expr.v1alpha1.Type in project java-smt by sosy-lab.

the class CVC4NativeAPITest method checkQuantifierWithUf.

@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");
}

Example 84 with Type

use of com.google.api.expr.v1alpha1.Type in project java-smt by sosy-lab.

the class CVC4NativeAPITest method checkCustomTypesAndUFs.

@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);
}

Example 85 with Type

use of com.google.api.expr.v1alpha1.Type in project openwebbeans by apache.

the class SubclassProxyFactory method delegateNonInterceptedMethods.

@Override
protected void delegateNonInterceptedMethods(ClassLoader classLoader, ClassWriter cw, String proxyClassFileName, Class<?> classToProxy, Method[] noninterceptedMethods) throws ProxyGenerationException {
    for (Method delegatedMethod : noninterceptedMethods) {
        if (unproxyableMethod(delegatedMethod)) {
            continue;
        }
        String methodDescriptor = Type.getMethodDescriptor(delegatedMethod);
        // X TODO handle generic exception types?
        Class[] exceptionTypes = delegatedMethod.getExceptionTypes();
        String[] exceptionTypeNames = new String[exceptionTypes.length];
        for (int i = 0; i < exceptionTypes.length; i++) {
            exceptionTypeNames[i] = Type.getType(exceptionTypes[i]).getInternalName();
        }
        int targetModifiers = delegatedMethod.getModifiers() & (Modifier.PROTECTED | Modifier.PUBLIC | MODIFIER_VARARGS);
        MethodVisitor mv = cw.visitMethod(targetModifiers, delegatedMethod.getName(), methodDescriptor, null, exceptionTypeNames);
        // fill method body
        mv.visitCode();
        boolean abstractMethod = Modifier.isAbstract(delegatedMethod.getModifiers());
        // now calculate the parameters
        int offset = 1;
        for (Class<?> aClass : delegatedMethod.getParameterTypes()) {
            Type type = Type.getType(aClass);
            mv.visitVarInsn(type.getOpcode(Opcodes.ILOAD), offset);
            offset += type.getSize();
        }
        // and finally invoke the target method on the provided Contextual Instance
        Type declaringClass = Type.getType(delegatedMethod.getDeclaringClass());
        if (!abstractMethod) {
            // invoke the method on the super class;
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, declaringClass.getInternalName(), delegatedMethod.getName(), methodDescriptor, false);
        }
        generateReturn(mv, delegatedMethod);
        mv.visitMaxs(-1, -1);
        mv.visitEnd();
    }
}