Examples with Model org.sbolstandard.core2.Model used on opensource projects

Example 31 with Model

use of org.sbolstandard.core2.Model in project bmoth by hhu-stups.

the class Issue73Test method testSatPredicateWithoutModel.

@Test
public void testSatPredicateWithoutModel() throws IOException {
    String formula = "1 < 2";
    BoolExpr constraint = translatePredicate(formula, z3Context);
    SolutionFinder finder = new SolutionFinder(z3Solver, z3Context);
    Set<Model> solutions = finder.findSolutions(constraint, 20);
    assertEquals(0, solutions.size());
}

Example 32 with Model

use of org.sbolstandard.core2.Model in project Dat3M by hernanponcedeleon.

the class Porthos method main.

public static void main(String[] args) throws Z3Exception, IOException {
    List<String> MCMs = Arrays.asList("sc", "tso", "pso", "rmo", "alpha", "power", "arm");
    Options options = new Options();
    Option sourceOpt = new Option("s", "source", true, "source MCM");
    sourceOpt.setRequired(true);
    options.addOption(sourceOpt);
    Option targetOpt = new Option("t", "target", true, "target MCM");
    targetOpt.setRequired(true);
    options.addOption(targetOpt);
    Option inputOpt = new Option("i", "input", true, "input file path");
    inputOpt.setRequired(true);
    options.addOption(inputOpt);
    options.addOption("state", false, "PORTHOS performs state portability");
    options.addOption(Option.builder("draw").hasArg().desc("If a buf is found, it outputs a graph \\path_to_file.dot").build());
    options.addOption(Option.builder("rels").hasArgs().desc("Relations to be drawn in the graph").build());
    options.addOption(Option.builder("unroll").hasArg().desc("Unrolling steps").build());
    CommandLineParser parserCmd = new DefaultParser();
    HelpFormatter formatter = new HelpFormatter();
    CommandLine cmd;
    try {
        cmd = parserCmd.parse(options, args);
    } catch (ParseException e) {
        System.out.println(e.getMessage());
        formatter.printHelp("PORTHOS", options);
        System.exit(1);
        return;
    }
    String source = cmd.getOptionValue("source");
    if (!MCMs.stream().anyMatch(mcms -> mcms.trim().equals(source))) {
        System.out.println("Unrecognized source");
        System.exit(0);
        return;
    }
    String target = cmd.getOptionValue("target");
    if (!MCMs.stream().anyMatch(mcms -> mcms.trim().equals(target))) {
        System.out.println("Unrecognized target");
        System.exit(0);
        return;
    }
    String inputFilePath = cmd.getOptionValue("input");
    if (!inputFilePath.endsWith("pts") && !inputFilePath.endsWith("litmus")) {
        System.out.println("Unrecognized program format");
        System.exit(0);
        return;
    }
    File file = new File(inputFilePath);
    boolean statePortability = cmd.hasOption("state");
    String[] rels = new String[100];
    if (cmd.hasOption("rels")) {
        rels = cmd.getOptionValues("rels");
    }
    String program = FileUtils.readFileToString(file, "UTF-8");
    ANTLRInputStream input = new ANTLRInputStream(program);
    Program p = new Program(inputFilePath);
    if (inputFilePath.endsWith("litmus")) {
        LitmusLexer lexer = new LitmusLexer(input);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        LitmusParser parser = new LitmusParser(tokens);
        p = parser.program(inputFilePath).p;
    }
    if (inputFilePath.endsWith("pts")) {
        PorthosLexer lexer = new PorthosLexer(input);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        PorthosParser parser = new PorthosParser(tokens);
        p = parser.program(inputFilePath).p;
    }
    int steps = 1;
    if (cmd.hasOption("unroll")) {
        steps = Integer.parseInt(cmd.getOptionValue("unroll"));
    }
    p.initialize(steps);
    Program pSource = p.clone();
    Program pTarget = p.clone();
    pSource.compile(source, false, true);
    Integer startEId = Collections.max(pSource.getEvents().stream().filter(e -> e instanceof Init).map(e -> e.getEId()).collect(Collectors.toSet())) + 1;
    pTarget.compile(target, false, true, startEId);
    Context ctx = new Context();
    ctx.setPrintMode(Z3_ast_print_mode.Z3_PRINT_SMTLIB_FULL);
    Solver s = ctx.mkSolver();
    Solver s2 = ctx.mkSolver();
    BoolExpr sourceDF = pSource.encodeDF(ctx);
    BoolExpr sourceCF = pSource.encodeCF(ctx);
    BoolExpr sourceDF_RF = pSource.encodeDF_RF(ctx);
    BoolExpr sourceDomain = Domain.encode(pSource, ctx);
    BoolExpr sourceMM = pSource.encodeMM(ctx, source);
    s.add(pTarget.encodeDF(ctx));
    s.add(pTarget.encodeCF(ctx));
    s.add(pTarget.encodeDF_RF(ctx));
    s.add(Domain.encode(pTarget, ctx));
    s.add(pTarget.encodeMM(ctx, target));
    s.add(pTarget.encodeConsistent(ctx, target));
    s.add(sourceDF);
    s.add(sourceCF);
    s.add(sourceDF_RF);
    s.add(sourceDomain);
    s.add(sourceMM);
    s.add(pSource.encodeInconsistent(ctx, source));
    s.add(encodeCommonExecutions(pTarget, pSource, ctx));
    s2.add(sourceDF);
    s2.add(sourceCF);
    s2.add(sourceDF_RF);
    s2.add(sourceDomain);
    s2.add(sourceMM);
    s2.add(pSource.encodeConsistent(ctx, source));
    if (!statePortability) {
        if (s.check() == Status.SATISFIABLE) {
            System.out.println("The program is not portable");
            // System.out.println("       0");
            if (cmd.hasOption("draw")) {
                String outputPath = cmd.getOptionValue("draw");
                Utils.drawGraph(p, pSource, pTarget, ctx, s.getModel(), outputPath, rels);
            }
            return;
        } else {
            System.out.println("The program is portable");
            // System.out.println("       1");
            return;
        }
    }
    int iterations = 0;
    Status lastCheck = Status.SATISFIABLE;
    Set<Expr> visited = new HashSet<Expr>();
    while (lastCheck == Status.SATISFIABLE) {
        lastCheck = s.check();
        if (lastCheck == Status.SATISFIABLE) {
            iterations = iterations + 1;
            Model model = s.getModel();
            s2.push();
            BoolExpr reachedState = encodeReachedState(pTarget, model, ctx);
            visited.add(reachedState);
            assert (iterations == visited.size());
            s2.add(reachedState);
            if (s2.check() == Status.UNSATISFIABLE) {
                System.out.println("The program is not state-portable");
                System.out.println("Iterations: " + iterations);
                // System.out.println("       0");
                return;
            } else {
                s2.pop();
                s.add(ctx.mkNot(reachedState));
            }
        } else {
            System.out.println("The program is state-portable");
            System.out.println("Iterations: " + iterations);
            // System.out.println("       1");
            return;
        }
    }
}

Example 33 with Model

use of org.sbolstandard.core2.Model in project batfish by batfish.

the class Encoder method verify.

/**
 * Checks that a property is always true by seeing if the encoding is unsatisfiable. mkIf the
 * model is satisfiable, then there is a counter example to the property.
 *
 * @return A VerificationResult indicating the status of the check.
 */
public Tuple<VerificationResult, Model> verify() {
    EncoderSlice mainSlice = _slices.get(MAIN_SLICE_NAME);
    int numVariables = _allVariables.size();
    int numConstraints = _solver.getAssertions().length;
    int numNodes = mainSlice.getGraph().getConfigurations().size();
    int numEdges = 0;
    for (Map.Entry<String, Set<String>> e : mainSlice.getGraph().getNeighbors().entrySet()) {
        numEdges += e.getValue().size();
    }
    long start = System.currentTimeMillis();
    Status status = _solver.check();
    long time = System.currentTimeMillis() - start;
    VerificationStats stats = null;
    if (_question.getBenchmark()) {
        stats = new VerificationStats();
        stats.setAvgNumNodes(numNodes);
        stats.setMaxNumNodes(numNodes);
        stats.setMinNumNodes(numNodes);
        stats.setAvgNumEdges(numEdges);
        stats.setMaxNumEdges(numEdges);
        stats.setMinNumEdges(numEdges);
        stats.setAvgNumVariables(numVariables);
        stats.setMaxNumVariables(numVariables);
        stats.setMinNumVariables(numVariables);
        stats.setAvgNumConstraints(numConstraints);
        stats.setMaxNumConstraints(numConstraints);
        stats.setMinNumConstraints(numConstraints);
        stats.setAvgSolverTime(time);
        stats.setMaxSolverTime(time);
        stats.setMinSolverTime(time);
    }
    if (status == Status.UNSATISFIABLE) {
        VerificationResult res = new VerificationResult(true, null, null, null, null, null, stats);
        return new Tuple<>(res, null);
    } else if (status == Status.UNKNOWN) {
        throw new BatfishException("ERROR: satisfiability unknown");
    } else {
        VerificationResult result;
        Model m;
        while (true) {
            m = _solver.getModel();
            SortedMap<String, String> model = new TreeMap<>();
            SortedMap<String, String> packetModel = new TreeMap<>();
            SortedSet<String> fwdModel = new TreeSet<>();
            SortedMap<String, SortedMap<String, String>> envModel = new TreeMap<>();
            SortedSet<String> failures = new TreeSet<>();
            buildCounterExample(this, m, model, packetModel, fwdModel, envModel, failures);
            if (_previousEncoder != null) {
                buildCounterExample(_previousEncoder, m, model, packetModel, fwdModel, envModel, failures);
            }
            result = new VerificationResult(false, model, packetModel, envModel, fwdModel, failures, stats);
            if (!_question.getMinimize()) {
                break;
            }
            BoolExpr blocking = environmentBlockingClause(m);
            add(blocking);
            Status s = _solver.check();
            if (s == Status.UNSATISFIABLE) {
                break;
            }
            if (s == Status.UNKNOWN) {
                throw new BatfishException("ERROR: satisfiability unknown");
            }
        }
        return new Tuple<>(result, m);
    }
}

Example 34 with Model

use of org.sbolstandard.core2.Model in project batfish by batfish.

the class PropertyChecker method checkDeterminism.

/*
   * Check if there exist multiple stable solutions to the network.
   * If so, reports the forwarding differences between the two cases.
   */
public AnswerElement checkDeterminism(HeaderQuestion q) {
    Graph graph = new Graph(_batfish);
    Encoder enc1 = new Encoder(_settings, graph, q);
    Encoder enc2 = new Encoder(enc1, graph, q);
    enc1.computeEncoding();
    enc2.computeEncoding();
    addEnvironmentConstraints(enc1, q.getBaseEnvironmentType());
    BoolExpr relatedFailures = relateFailures(enc1, enc2);
    BoolExpr relatedEnvs = relateEnvironments(enc1, enc2);
    BoolExpr relatedPkts = relatePackets(enc1, enc2);
    BoolExpr related = enc1.mkAnd(relatedFailures, relatedEnvs, relatedPkts);
    BoolExpr required = enc1.mkTrue();
    for (GraphEdge ge : graph.getAllRealEdges()) {
        SymbolicDecisions d1 = enc1.getMainSlice().getSymbolicDecisions();
        SymbolicDecisions d2 = enc2.getMainSlice().getSymbolicDecisions();
        BoolExpr dataFwd1 = d1.getDataForwarding().get(ge.getRouter(), ge);
        BoolExpr dataFwd2 = d2.getDataForwarding().get(ge.getRouter(), ge);
        assert dataFwd1 != null;
        assert dataFwd2 != null;
        required = enc1.mkAnd(required, enc1.mkEq(dataFwd1, dataFwd2));
    }
    enc1.add(related);
    enc1.add(enc1.mkNot(required));
    Tuple<VerificationResult, Model> tup = enc1.verify();
    VerificationResult res = tup.getFirst();
    Model model = tup.getSecond();
    SortedSet<String> case1 = null;
    SortedSet<String> case2 = null;
    Flow flow = null;
    CounterExample ce = new CounterExample(model);
    if (!res.isVerified()) {
        case1 = new TreeSet<>();
        case2 = new TreeSet<>();
        flow = ce.buildFlow(enc1.getMainSlice().getSymbolicPacket(), "(none)");
        for (GraphEdge ge : graph.getAllRealEdges()) {
            SymbolicDecisions d1 = enc1.getMainSlice().getSymbolicDecisions();
            SymbolicDecisions d2 = enc2.getMainSlice().getSymbolicDecisions();
            BoolExpr dataFwd1 = d1.getDataForwarding().get(ge.getRouter(), ge);
            BoolExpr dataFwd2 = d2.getDataForwarding().get(ge.getRouter(), ge);
            assert dataFwd1 != null;
            assert dataFwd2 != null;
            boolean b1 = ce.boolVal(dataFwd1);
            boolean b2 = ce.boolVal(dataFwd2);
            if (b1 != b2) {
                if (b1) {
                    String route = ce.buildRoute(enc1.getMainSlice(), ge);
                    String msg = ge + " -- " + route;
                    case1.add(msg);
                }
                if (b2) {
                    String route = ce.buildRoute(enc2.getMainSlice(), ge);
                    String msg = ge + " -- " + route;
                    case2.add(msg);
                }
            }
        }
    }
    // Ensure canonical order
    boolean less = (case1 == null || (case1.first().compareTo(case2.first()) < 0));
    if (less) {
        return new SmtDeterminismAnswerElement(flow, case1, case2);
    } else {
        return new SmtDeterminismAnswerElement(flow, case2, case1);
    }
}

Example 35 with Model

use of org.sbolstandard.core2.Model in project xtext-core by eclipse.

the class Bug305397SemanticSequencer method sequence.

@Override
public void sequence(ISerializationContext context, EObject semanticObject) {
    EPackage epackage = semanticObject.eClass().getEPackage();
    ParserRule rule = context.getParserRule();
    Action action = context.getAssignedAction();
    Set<Parameter> parameters = context.getEnabledBooleanParameters();
    if (epackage == Bug305397Package.eINSTANCE)
        switch(semanticObject.eClass().getClassifierID()) {
            case Bug305397Package.ELEMENT:
                sequence_Element(context, (Element) semanticObject);
                return;
            case Bug305397Package.MODEL:
                sequence_Model(context, (Model) semanticObject);
                return;
        }
    if (errorAcceptor != null)
        errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
}