Examples with AgreeStatement com.rockwellcollins.atc.agree.analysis.ast.AgreeStatement used on opensource projects

Example 41 with AgreeStatement

use of com.rockwellcollins.atc.agree.analysis.ast.AgreeStatement in project AGREE by loonwerks.

the class RenamingVisitor method getReferenceStr.

private String getReferenceStr(AgreeVar var) {
    String prefix = getCategory(rootInstance, var);
    if (prefix == null) {
        return null;
    }
    if (var.id.endsWith(AgreeASTBuilder.clockIDSuffix)) {
        return null;
    }
    String seperator = (prefix == "" ? "" : ".");
    EObject reference = var.reference;
    String suffix = "";
    if (var.id.endsWith(AgreeASTBuilder.eventSuffix + AgreeInlineLatchedConnections.LATCHED_SUFFIX)) {
        suffix = "._EVENT_._LATCHED_";
    } else if (var.id.endsWith(AgreeASTBuilder.eventSuffix)) {
        suffix = "._EVENT_";
    } else if (var.id.endsWith(AgreeInlineLatchedConnections.LATCHED_SUFFIX)) {
        suffix = "._LATCHED_";
    }
    if (reference instanceof GuaranteeStatement) {
        String id = ((GuaranteeStatement) reference).getName();
        if (id == null || id.isEmpty()) {
            id = "";
        } else {
            id = "[" + id + "] ";
        }
        return id + ((GuaranteeStatement) reference).getStr();
    } else if (reference instanceof AssumeStatement) {
        String id = ((AssumeStatement) reference).getName();
        if (id == null || id.isEmpty()) {
            id = "";
        } else {
            id = "[" + id + "] ";
        }
        return prefix + " assume: " + id + ((AssumeStatement) reference).getStr();
    } else if (reference instanceof LemmaStatement) {
        String id = ((LemmaStatement) reference).getName();
        if (id == null || id.isEmpty()) {
            id = "";
        } else {
            id = "[" + id + "] ";
        }
        return prefix + " lemma: " + id + ((LemmaStatement) reference).getStr();
    } else if (reference instanceof ReachableStatement) {
        renaming.addInvertedProperty(var.id);
        String id = ((ReachableStatement) reference).getName();
        if (id == null || id.isEmpty()) {
            id = "";
        } else {
            id = "[" + id + "] ";
        }
        return prefix + " reachable: " + id + ((ReachableStatement) reference).getStr();
    } else if (reference instanceof AssertStatement) {
        throw new AgreeException("We really didn't expect to see an assert statement here");
    } else if (reference instanceof Arg) {
        return prefix + seperator + ((Arg) reference).getName() + suffix;
    } else if (reference instanceof EqStatement) {
        return prefix + "eq " + String.join(", ", ((EqStatement) reference).getLhs().stream().map(lhs -> argToString(lhs)).collect(Collectors.toList()));
    } else if (reference instanceof InputStatement) {
        return prefix + "agree_input " + String.join(", ", ((InputStatement) reference).getLhs().stream().map(lhs -> argToString(lhs)).collect(Collectors.toList()));
    } else if (reference instanceof DataPort) {
        return prefix + seperator + ((DataPort) reference).getName() + suffix;
    } else if (reference instanceof EventPort) {
        return prefix + seperator + ((EventPort) reference).getName() + suffix;
    } else if (reference instanceof EventDataPort) {
        return prefix + seperator + ((EventDataPort) reference).getName() + suffix;
    } else if (reference instanceof FeatureGroup) {
        String featName = ((FeatureGroup) reference).getName();
        String varName = var.toString();
        featName = varName.substring(varName.indexOf(featName)).replace("__", ".");
        return prefix + seperator + featName;
    } else if (reference instanceof PropertyStatement) {
        return prefix + seperator + ((PropertyStatement) reference).getName();
    } else if (reference instanceof Property) {
        return "AADL property " + ((Property) reference).getName();
    } else if (reference instanceof GetPropertyExpr) {
        return "Get_Property(" + ((GetPropertyExpr) reference).getContainingClassifier().getName() + ", " + ((Property) ((GetPropertyExpr) reference).getProp()).getName() + ")";
    } else if (reference instanceof ComponentType || reference instanceof ComponentImplementation || reference instanceof SystemImplementation) {
        if (var.id.equals(LustreAstBuilder.assumeHistSufix)) {
            return "Subcomponent Assumptions";
        }
        return "Result";
    } else if (reference instanceof AgreeStatement) {
        return prefix + reference.toString();
    }
    throw new AgreeException("Unhandled reference type: '" + reference.getClass().getName() + "'");
}

Example 42 with AgreeStatement

use of com.rockwellcollins.atc.agree.analysis.ast.AgreeStatement in project AGREE by loonwerks.

the class AgreePatternTranslator method translateNode.

private AgreeNode translateNode(AgreeNode node, boolean isTopNode) {
    AgreeNodeBuilder builder = new AgreeNodeBuilder(node);
    // this has to be done first because the pattern translation
    // for guarantees/lemmas/assumptions add additional assertions
    builder.clearAssertions();
    createTimeFunctions(node, builder);
    for (AgreeStatement statement : node.assertions) {
        if (statement instanceof AgreePattern) {
            containsRealTimePatterns = true;
            Expr transExpr = translatePattern((AgreePattern) statement, builder, false);
            statement = new AgreeStatement(statement.string, transExpr, statement.reference);
        }
        builder.addAssertion(statement);
    }
    builder.clearGuarantees();
    for (AgreeStatement statement : node.guarantees) {
        if (statement instanceof AgreePattern) {
            containsRealTimePatterns = true;
            Expr transExpr = translatePattern((AgreePattern) statement, builder, isTopNode);
            statement = new AgreeStatement(statement.string, transExpr, statement.reference);
        }
        builder.addGuarantee(statement);
    }
    builder.clearLemmas();
    for (AgreeStatement statement : node.lemmas) {
        if (statement instanceof AgreePattern) {
            containsRealTimePatterns = true;
            Expr transExpr = translatePattern((AgreePattern) statement, builder, isTopNode);
            statement = new AgreeStatement(statement.string, transExpr, statement.reference);
        }
        builder.addLemma(statement);
    }
    builder.clearAssumptions();
    for (AgreeStatement statement : node.assumptions) {
        if (statement instanceof AgreePattern) {
            containsRealTimePatterns = true;
            Expr transExpr = translatePattern((AgreePattern) statement, builder, !isTopNode);
            statement = new AgreeStatement(statement.string, transExpr, statement.reference);
        }
        builder.addAssumption(statement);
    }
    builder.clearSubNodes();
    for (AgreeNode subNode : node.subNodes) {
        builder.addSubNode(new AgreePatternTranslator().translateNode(subNode, false));
    }
    builder.addInput(new AgreeVar(timeExpr.id, NamedType.REAL, null, node.compInst, null));
    return builder.build();
}

Example 43 with AgreeStatement

use of com.rockwellcollins.atc.agree.analysis.ast.AgreeStatement in project AGREE by loonwerks.

the class AgreePatternTranslator method translatePatternCondition.

private Expr translatePatternCondition(AgreePeriodicPattern pattern, AgreeNodeBuilder builder, EObject varReference) {
    AgreeVar jitterVar = new AgreeVar(JITTER_PREFIX + patternIndex, NamedType.REAL, varReference);
    AgreeVar periodVar = new AgreeVar(PERIOD_PREFIX + patternIndex, NamedType.REAL, varReference);
    AgreeVar timeoutVar = new AgreeVar(TIMEOUT_PREFIX + patternIndex, NamedType.REAL, varReference);
    builder.addOutput(jitterVar);
    builder.addOutput(periodVar);
    builder.addOutput(timeoutVar);
    IdExpr jitterId = new IdExpr(jitterVar.id);
    IdExpr periodId = new IdExpr(periodVar.id);
    IdExpr timeoutId = new IdExpr(timeoutVar.id);
    builder.addEventTime(timeoutVar);
    // -j <= jitter <= j
    Expr jitterLow = new BinaryExpr(new UnaryExpr(UnaryOp.NEGATIVE, pattern.jitter), BinaryOp.LESSEQUAL, jitterId);
    Expr jitterHigh = new BinaryExpr(jitterId, BinaryOp.LESSEQUAL, pattern.jitter);
    builder.addAssertion(new AgreeStatement(null, new BinaryExpr(jitterLow, BinaryOp.AND, jitterHigh), pattern.reference));
    Expr expr = expr("(0.0 <= period) and (period < p) -> " + "(period = (pre period) + (if pre(e) then p else 0.0))", to("period", periodVar), to("p", pattern.period), to("e", pattern.event));
    builder.addAssertion(new AgreeStatement(null, expr, pattern.reference));
    // helper assertion (should be true)
    Expr lemma = expr("period - time < p - j and period >= time", to("period", periodVar), to("p", pattern.period), to("time", timeExpr), to("j", pattern.jitter));
    builder.addAssertion(new AgreeStatement(null, lemma, pattern.reference));
    AgreeVar timeofEvent = getTimeOf(pattern.event.id, builder, null);
    lemma = expr("(timeOfEvent >= 0.0 and timeOfEvent <> time => timeout - timeOfEvent >= p - j) and " + "(true -> (period <> pre(period) => period - pre(period) <= p + j)) and " + "(timeOfEvent >= 0.0 => timeout - timeOfEvent <= p + j)", to("timeOfEvent", timeofEvent), to("time", timeExpr), to("timeout", timeoutId), to("p", pattern.period), to("j", pattern.jitter), to("period", periodVar));
    builder.addPatternProp(new AgreeStatement("periodic lemma 1 for pattern " + patternIndex, lemma, pattern.reference));
    lemma = expr("true -> timeout <> pre(timeout) => timeout - pre(timeout) >= p - j", to("timeout", timeoutId), to("p", pattern.period), to("j", pattern.jitter));
    builder.addPatternProp(new AgreeStatement("periodic lemma 2 for pattern " + patternIndex, lemma, pattern.reference));
    // timeout = pnext + jitter
    Expr timeoutExpr = new BinaryExpr(periodId, BinaryOp.PLUS, jitterId);
    timeoutExpr = new BinaryExpr(timeoutId, BinaryOp.EQUAL, timeoutExpr);
    builder.addAssertion(new AgreeStatement(null, timeoutExpr, pattern.reference));
    // event = (t = timeout)
    Expr eventExpr = new BinaryExpr(timeExpr, BinaryOp.EQUAL, timeoutId);
    eventExpr = new BinaryExpr(pattern.event, BinaryOp.EQUAL, eventExpr);
    return eventExpr;
}

Example 44 with AgreeStatement

use of com.rockwellcollins.atc.agree.analysis.ast.AgreeStatement in project AGREE by loonwerks.

the class AgreePatternTranslator method translatePatternConditionProperty.

private Expr translatePatternConditionProperty(AgreeCauseEffectPattern pattern, AgreeNodeBuilder builder, IdExpr causeId, IdExpr effectId) {
    EObject varReference = pattern.reference;
    AgreeVar recordVar = new AgreeVar(RECORD_PREFIX + patternIndex, NamedType.BOOL, varReference);
    AgreeVar windowVar = new AgreeVar(WINDOW_PREFIX + patternIndex, NamedType.BOOL, varReference);
    builder.addInput(recordVar);
    builder.addLocal(windowVar);
    AgreeVar tRecord = getTimeOf(recordVar.id, builder, pattern);
    Expr expr = expr("record => cause", to("record", recordVar), to("cause", causeId));
    builder.addAssertion(new AgreeStatement(null, expr, varReference));
    BinaryOp left = getIntervalLeftOp(pattern.effectInterval);
    BinaryOp right = getIntervalRightOp(pattern.effectInterval);
    Equation eq = equation("in_window = (trecord <> -1.0) and " + "(l + trecord " + left + " time) and (time " + right + " h + trecord);", to("in_window", windowVar), to("trecord", tRecord), to("time", timeExpr), to("l", pattern.effectInterval.low), to("h", pattern.effectInterval.high));
    builder.addLocalEquation(new AgreeEquation(eq, varReference));
    return expr("in_window => effect", to("in_window", windowVar), to("effect", effectId));
}

Example 45 with AgreeStatement

use of com.rockwellcollins.atc.agree.analysis.ast.AgreeStatement in project AGREE by loonwerks.

the class AgreePatternTranslator method translatePatternEventProperty.

private Expr translatePatternEventProperty(AgreeCauseEffectPattern pattern, AgreeNodeBuilder builder, IdExpr causeId, IdExpr effectId) {
    EObject varReference = pattern.reference;
    AgreeVar timerVar = new AgreeVar(TIMER_PREFIX + patternIndex, NamedType.REAL, varReference);
    AgreeVar runVar = new AgreeVar(RUNNING_PREFIX + patternIndex, NamedType.BOOL, varReference);
    AgreeVar recordVar = new AgreeVar(RECORD_PREFIX + patternIndex, NamedType.BOOL, varReference);
    builder.addLocal(timerVar);
    builder.addLocal(runVar);
    builder.addInput(recordVar);
    IdExpr timerId = new IdExpr(timerVar.id);
    IdExpr runId = new IdExpr(runVar.id);
    IdExpr recordId = new IdExpr(recordVar.id);
    // run = record -> if pre(run) and e and l <= timer <= h then
    // false
    // else
    // if record then
    // true
    // else
    // pre(run)
    Expr preRun = new UnaryExpr(UnaryOp.PRE, runId);
    {
        Expr if2 = new IfThenElseExpr(recordId, new BoolExpr(true), preRun);
        BinaryOp left = getIntervalLeftOp(pattern.effectInterval);
        BinaryOp right = getIntervalRightOp(pattern.effectInterval);
        Expr timerLow = new BinaryExpr(pattern.effectInterval.low, left, timerId);
        Expr timerHigh = new BinaryExpr(timerId, right, pattern.effectInterval.high);
        Expr cond1 = new BinaryExpr(preRun, BinaryOp.AND, effectId);
        cond1 = new BinaryExpr(cond1, BinaryOp.AND, timerLow);
        cond1 = new BinaryExpr(cond1, BinaryOp.AND, timerHigh);
        Expr if1 = new IfThenElseExpr(cond1, new BoolExpr(false), if2);
        Expr runExpr = new BinaryExpr(recordId, BinaryOp.ARROW, if1);
        builder.addLocalEquation(new AgreeEquation(runId, runExpr, varReference));
    }
    // timer = (0 -> if pre(run) then pre(timer) + (t - pre(t)) else 0)
    {
        Expr preTimer = new UnaryExpr(UnaryOp.PRE, timerId);
        Expr preT = new UnaryExpr(UnaryOp.PRE, timeExpr);
        Expr elapsed = new BinaryExpr(timeExpr, BinaryOp.MINUS, preT);
        Expr total = new BinaryExpr(preTimer, BinaryOp.PLUS, elapsed);
        Expr timerExpr = new IfThenElseExpr(preRun, total, new RealExpr(BigDecimal.ZERO));
        timerExpr = new BinaryExpr(new RealExpr(BigDecimal.ZERO), BinaryOp.ARROW, timerExpr);
        builder.addLocalEquation(new AgreeEquation(timerId, timerExpr, varReference));
    }
    // property that should be true for timer to help induction
    {
        Expr expr = new BinaryExpr(timerId, BinaryOp.GREATEREQUAL, new RealExpr(BigDecimal.ZERO));
        builder.addAssertion(new AgreeStatement(null, expr, varReference));
    }
    // record => cause and not (e and (l = 0))
    {
        Expr causeExpr;
        if (pattern.effectInterval.type == IntervalType.OPEN_LEFT || pattern.effectInterval.type == IntervalType.OPEN) {
            causeExpr = causeId;
        } else {
            Expr eAndLZero = new BinaryExpr(pattern.effectInterval.low, BinaryOp.EQUAL, new RealExpr(BigDecimal.ZERO));
            eAndLZero = new BinaryExpr(effectId, BinaryOp.AND, eAndLZero);
            Expr notEAndLZero = new UnaryExpr(UnaryOp.NOT, eAndLZero);
            causeExpr = new BinaryExpr(causeId, BinaryOp.AND, notEAndLZero);
        }
        Expr recordExpr = new BinaryExpr(recordId, BinaryOp.IMPLIES, causeExpr);
        AgreeStatement statement = new AgreeStatement(null, recordExpr, varReference);
        builder.addAssertion(statement);
    }
    // lemma to help induction
    AgreeVar timeOfCause = getTimeOf(causeId.id, builder, pattern);
    AgreeVar timeOfEffect = getTimeOf(effectId.id, builder, pattern);
    // Expr expr = expr("(timer > 0.0 => timeOfCause > 0.0) and "
    // + "(timeOfEffect < timeOfCause => timer <= time - timeOfCause) and "
    // + "(cause => timeOfCause = time) and"
    // + "(true -> ((pre (timeOfEffect - low > timeOfCause)) => timer =
    // 0.0))",
    // to("timer", timerVar),
    // to("timeOfCause", timeOfCause),
    // to("time", timeExpr),
    // to("cause", causeId),
    // to("timeOfEffect", timeOfEffect),
    // to("low", pattern.effectInterval.low));
    Expr expr = expr("(timer > 0.0 => timeOfCause >= 0.0) and " + "(timer <= time) and" + "(timeOfEffect >= timeOfCause and timer <= high and timeOfEffect >= time - timer + low => not run) and" + "(true -> (pre(timeOfEffect >= timeOfCause + low and timeOfEffect <= timeOfCause + high and timer <= high) => timer = 0.0)) and" + "(timer = 0.0 or timer >= time - timeOfCause)", to("timer", timerVar), to("timeOfCause", timeOfCause), to("timeOfEffect", timeOfEffect), to("time", timeExpr), to("low", pattern.effectInterval.low), to("high", pattern.effectInterval.high), to("run", runVar));
    builder.addPatternProp(new AgreeStatement("Timer Lemma for Pattern " + patternIndex, expr, pattern));
    // timer <= h
    BinaryOp right = getIntervalRightOp(pattern.effectInterval);
    return new BinaryExpr(timerId, right, pattern.effectInterval.high);
}