示例#1
0
def main():
    parser = argparse.ArgumentParser(description='I check a TLSF SYNTCOMP solver on several benchmarks',
                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument('solver', metavar='solver', type=str,
                        help='Solver command (I will run using "<solver> <tlsf_spec>")')
    parser.add_argument('--all', action='store_true', required=False, default=False,
                        help="run all benchmarks including the hard ones")
    parser.add_argument('--nonstop', action='store_true', required=False, default=False,
                        help="don't stop on error")
    parser.add_argument('--mc', action='store_true', required=False, default=False,
                        help="model check the results")
    parser.add_argument('-v', '--verbose', action='count', default=0)

    args = parser.parse_args()
    setup_logging(args.verbose)
    logging.info(args)

    benchmarks = easy if not args.all else easy + hard

    all_passed = True
    for is_real, bench in benchmarks:
        logging.info('testing ' + BENCHMARKS_DIR + bench)
        fail_reason = _run_benchmark(args.solver, is_real==1, BENCHMARKS_DIR + bench, args.mc)
        if fail_reason:
            all_passed = False
            logging.info('test failed, reason:\n' + fail_reason)
            if not args.nonstop:
                return 1

    logging.info('-' * 80)
    logging.info(['SOME TESTS FAILED', 'ALL TESTS PASSED'][all_passed])
    return 0
示例#2
0
def main() -> None:
    parser = argparse.ArgumentParser(
        description='CTL* to LTL converter for synthesis',
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)

    parser.add_argument('spec',
                        metavar='spec',
                        type=str,
                        help='the specification file (in python format)')

    parser.add_argument(
        '--k',
        default=None,
        type=int,
        help='force the value of parameter k (the number of IDs)')

    parser.add_argument('--out',
                        '-o',
                        default=None,
                        type=str,
                        help='file name to output TLSF')

    parser.add_argument('--log',
                        metavar='log',
                        type=str,
                        required=False,
                        default=None,
                        help='name of the log file')

    parser.add_argument('-v', '--verbose', action='count', default=0)

    args = parser.parse_args()

    setup_logging(args.verbose, args.log)
    logging.info(args)

    spec = parse_python_spec(args.spec)

    logging.info('Input spec:\n' + str(spec))

    new_spec = ctlstar2ltl.convert(spec, args.k, LTLToAtmViaSpot())

    logging.info('introduced outputs:\n%s',
                 pformat(new_spec.outputs - spec.outputs))
    logging.info('LTL\n%s',
                 ConverterToLtl2BaFormatVisitor().dispatch(new_spec.formula))
    tlsf_str = spec_to_tlsf.convert(new_spec)
    print(tlsf_str)
    if args.out:
        with open(args.out, 'w') as f:
            f.write(tlsf_str)
        logging.info("output TLSF is written to: " + args.out)
示例#3
0
def main():
    parser = argparse.ArgumentParser(
        description='Convert Verilog to AIGER',
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)

    parser.add_argument('verilog',
                        metavar='verilog',
                        type=str,
                        help='input verilog file')
    parser.add_argument('-v', '--verbose', action='count', default=0)
    args = parser.parse_args()

    setup_logging(args.verbose)

    args = parser.parse_args()
    v_file = args.verilog
    print(verilog_to_aiger(readfile(v_file)))
示例#4
0
def main_template(tool_desc: str, tasks_creator: TaskCreator):
    parser = argparse.ArgumentParser(
        description=tool_desc,
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)

    parser.add_argument('spec',
                        metavar='spec',
                        type=str,
                        help='TLSF or Acacia (Lily) spec file')
    parser.add_argument('-o',
                        '--output',
                        metavar='output',
                        type=str,
                        help='output file for a model in AIGER format '
                        '(if not given -- print to stdout)')
    parser.add_argument('--dot',
                        metavar='dot',
                        type=str,
                        help='write the output into a dot graph file')
    group = parser.add_mutually_exclusive_group()
    group.add_argument('--moore',
                       action='store_true',
                       default=True,
                       dest='moore',
                       help='system is Moore (ignored for TLSF)')
    group.add_argument('--mealy',
                       action='store_false',
                       default=False,
                       dest='moore',
                       help='system is Mealy (ignored for TLSF)')
    parser.add_argument('-v',
                        '--verbose',
                        action='count',
                        default=-1,
                        help='verbosity level')

    args = parser.parse_args()

    setup_logging(args.verbose, name_processes=True)
    logging.info(args)

    run_and_report(args.spec, args.moore, args.output, args.dot, tasks_creator)
示例#5
0
文件: elli.py 项目: 5nizza/party-elli
def main():
    """ :return: 1 if model is found, 0 otherwise """

    parser = argparse.ArgumentParser(
        description="Bounded Synthesis Tool", formatter_class=argparse.ArgumentDefaultsHelpFormatter
    )

    parser.add_argument("spec", metavar="spec", type=str, help="the specification file (acacia+ format)")

    group = parser.add_mutually_exclusive_group()  # default: moore=False, mealy=True
    group.add_argument("--moore", action="store_true", default=False, help="system is Moore")
    group.add_argument("--mealy", action="store_false", default=True, help="system is Mealy")

    group = parser.add_mutually_exclusive_group()
    group.add_argument(
        "--bound",
        metavar="bound",
        type=int,
        default=128,
        required=False,
        help="upper bound on the size of the model (for unreal this specifies size of env model)",
    )
    group.add_argument(
        "--size",
        metavar="size",
        type=int,
        default=0,
        required=False,
        help="search the model of this size (for unreal this specifies size of env model)",
    )

    parser.add_argument("--incr", action="store_true", required=False, default=False, help="use incremental solving")
    parser.add_argument("--tmp", action="store_true", required=False, default=False, help="keep temporary smt2 files")
    parser.add_argument("--dot", metavar="dot", type=str, required=False, help="write the output into a dot graph file")
    parser.add_argument("--log", metavar="log", type=str, required=False, default=None, help="name of the log file")
    parser.add_argument(
        "--unreal",
        action="store_true",
        required=False,
        help="simple check of unrealizability: "
        "invert the spec, system type, (in/out)puts, "
        "and synthesize the model for env "
        "(a more sophisticated check could search for env that disproves systems of given size)"
        "(note that the inverted spec will NOT be strengthened)",
    )
    parser.add_argument("-v", "--verbose", action="count", default=0)

    args = parser.parse_args()

    setup_logging(args.verbose, args.log)
    logging.info(args)

    if args.incr and args.tmp:
        logging.warning(
            "--tmp --incr: incremental queries do not produce smt2 files, " "so I won't save any temporal files."
        )

    with tempfile.NamedTemporaryFile(dir="./") as smt_file:
        smt_files_prefix = smt_file.name

    ltl3ba, solver_factory = create_spec_converter_z3(UFLRA(), args.incr, False, smt_files_prefix, not args.tmp)
    if args.size == 0:
        min_size, max_size = 1, args.bound
    else:
        min_size, max_size = args.size, args.size

    ltl_text, part_text = readfile(args.spec), readfile(args.spec.replace(".ltl", ".part"))
    if not args.unreal:
        model = check_real(ltl_text, part_text, args.moore, ltl3ba, solver_factory, min_size, max_size)
    else:
        model = check_unreal(ltl_text, part_text, args.moore, ltl3ba, solver_factory, min_size, max_size)

    logging.info(
        "{status} model for {who}".format(status=("FOUND", "NOT FOUND")[model is None], who=("sys", "env")[args.unreal])
    )
    if model:
        dot_model_str = lts_to_dot(model, ARG_MODEL_STATE, (not args.moore) ^ args.unreal)

        if args.dot:
            with open(args.dot, "w") as out:
                out.write(dot_model_str)
                logging.info(
                    "{model_type} model is written to {file}".format(
                        model_type=["Mealy", "Moore"][args.moore], file=out.name
                    )
                )
        else:
            logging.info(dot_model_str)

    solver_factory.down_solvers()

    return UNKNOWN if model is None else (REALIZABLE, UNREALIZABLE)[args.unreal]
示例#6
0
    return 0


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description='ctl* -> aht -> dot. Print the result to stdout.',
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)

    parser.add_argument('spec',
                        metavar='spec',
                        type=str,
                        help='spec file (python code)')

    parser.add_argument('--all',
                        action='store_true',
                        required=False,
                        default=False,
                        help='print all automata and transitions generated'
                        '(rather than only those belonging to AHT)')

    parser.add_argument('-v', '--verbose', action='count', default=0)

    args = parser.parse_args()

    setup_logging(args.verbose)
    logging.debug(args)

    status = main(args.spec, args.all)
    exit(status)
示例#7
0
文件: p_bosy.py 项目: vraman/Party
                        help='call solver with incremental queries')
    parser.add_argument('--cincr',
                        action='store_true',
                        required=False,
                        default=False,
                        help='try smaller cutoff sizes first')
    parser.add_argument(
        '--opt',
        choices=sorted(list(OPTS.keys()), key=lambda v: OPTS[v]),
        required=False,
        default=ASYNC_HUB,
        help='apply an optimization (choose one) (default: %(default)s)')

    args = parser.parse_args(sys.argv[1:])

    logger = setup_logging(args.verbose)

    logger.info(args)

    with tempfile.NamedTemporaryFile(dir='./') as smt_file:
        smt_files_prefix = smt_file.name

    ltl2ucw_converter, z3solver_factory = create_spec_converter_z3(
        logger, UFLIA(None), args.incr, smt_files_prefix)
    if not ltl2ucw_converter or not z3solver_factory:
        exit(0)

    bounds = list(
        range(2, args.bound +
              1) if args.size == 0 else range(args.size, args.size + 1))
示例#8
0
def main():
    parser = argparse.ArgumentParser(
        description='LTL synthesizer via k-reduction to AIGER',
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument('spec',
                        metavar='spec',
                        type=str,
                        help='TLSF or Wring (Acacia) spec file')
    parser.add_argument(
        '--minK',
        default=2,
        required=False,
        type=int,
        help='min max number of visits to a bad state (within one SCC)')
    parser.add_argument(
        '--maxK',
        default=8,
        required=False,
        type=int,
        help='max max number of visits to a bad state (within one SCC)')
    parser.add_argument(
        '-o',
        '--output',
        metavar='output',
        type=str,
        help=
        'output file for a model in the AIGER format (if not given -- print to stdout)'
    )
    group = parser.add_mutually_exclusive_group()
    group.add_argument('--moore',
                       action='store_true',
                       default=False,
                       dest='moore',
                       help='system is Moore (ignored for TLSF)')
    group.add_argument('--mealy',
                       action='store_false',
                       default=True,
                       dest='moore',
                       help='system is Mealy (ignored for TLSF)')
    parser.add_argument('--unreal',
                        action='store_true',
                        required=False,
                        help='check unrealizability: '
                        'negate the spec, system type, (in/out)puts, '
                        'and synthesize a model for the env '
                        '(note the spec will NOT be strengthened)')
    parser.add_argument('-v',
                        '--verbose',
                        action='count',
                        default=0,
                        help='verbosity level')

    args = parser.parse_args()

    setup_logging(args.verbose)
    logging.info(args)

    ltl_text, part_text, is_moore = convert_tlsf_or_acacia_to_acacia(
        args.spec, args.moore)

    ltl_to_atm = LTLToAtmViaSpot()

    if not args.unreal:
        aiger_str = check_real(ltl_text, part_text, is_moore, ltl_to_atm,
                               args.minK, args.maxK, 0)
        if aiger_str is None:
            print_syntcomp_unknown()
            return UNKNOWN_RC

        if args.output:
            with open(args.output, 'w') as out:
                out.write(aiger_str)
        print_syntcomp_real(aiger_str)
        return REALIZABLE_RC
    else:
        aiger_str = check_unreal(ltl_text, part_text, is_moore, ltl_to_atm,
                                 args.minK, args.maxK, 0)
        if aiger_str:
            logging.info('found model for env (not going to print it)')
            # with open('/tmp/env.aag', 'w') as out:
            #     out.write(aiger_str)
            print_syntcomp_unreal()
            return UNREALIZABLE_RC
        else:
            print_syntcomp_unknown()
            return UNKNOWN_RC
示例#9
0
def main():
    parser = argparse.ArgumentParser(
        description=
        'Translate LTL spec (TLSF or Acacia format) into AIGER via k-Live automata.',
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)

    parser.add_argument('spec',
                        metavar='spec',
                        type=str,
                        help='input spec (in Wring or TLSF format)')

    parser.add_argument(
        '--k',
        '-k',
        default=8,
        required=False,
        type=int,
        help='max number of visits to a bad state (within one SCC)')

    gr = parser.add_mutually_exclusive_group()
    gr.add_argument('--spot',
                    action='store_true',
                    default=True,
                    dest='spot',
                    help='use SPOT for translating LTL->BA')
    gr.add_argument('--ltl3ba',
                    action='store_false',
                    default=False,
                    dest='spot',
                    help='use LTL3BA for translating LTL->BA')

    parser.add_argument('--mealy',
                        action='store_true',
                        default=False,
                        dest='acacia_mealy',
                        help='(for Acacia only) force Mealy machines')

    parser.add_argument(
        '--noopt',
        action='store_true',
        default=False,
        dest='noopt',
        help=
        'Do not strengthen the specification (using the separation into safety-liveness)'
    )

    parser.add_argument('--out',
                        '-o',
                        required=False,
                        type=str,
                        help='output AIGER file')

    parser.add_argument('-v', '--verbose', action='count', default=0)

    args = parser.parse_args()
    setup_logging(args.verbose)
    print(args)

    ltl_to_automaton = (translator_via_ltl3ba.LTLToAtmViaLTL3BA,
                        translator_via_spot.LTLToAtmViaSpot
                        )[args.spot]()  # type: LTLToAutomaton

    ltl_text, part_text, is_moore = convert_tlsf_or_acacia_to_acacia(
        args.spec, not args.acacia_mealy)

    spec = parse_acacia_and_build_expr(ltl_text, part_text, ltl_to_automaton,
                                       0 if args.noopt else 2)

    ucw_automaton = ltl_to_automaton.convert(spec.formula)

    aiger_str = convert_spec_to_aiger(spec.inputs, spec.outputs, ucw_automaton,
                                      args.k, 'bad')
    if args.out:
        with open(args.out, 'w') as f:
            f.write(aiger_str)
    else:
        print(aiger_str)
示例#10
0
def main():
    parser = argparse.ArgumentParser(
        description='Bounded Synthesis Tool',
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)

    parser.add_argument('spec',
                        metavar='spec',
                        type=str,
                        help='the specification file (Acacia or TLSF format)')

    gr = parser.add_mutually_exclusive_group()
    gr.add_argument('--moore',
                    action='store_true',
                    default=True,
                    dest='moore',
                    help='system is Moore (ignored for TLSF)')
    gr.add_argument('--mealy',
                    action='store_false',
                    default=False,
                    dest='moore',
                    help='system is Mealy (ignored for TLSF)')

    gr = parser.add_mutually_exclusive_group()
    gr.add_argument('--spot',
                    action='store_true',
                    default=True,
                    dest='spot',
                    help='use SPOT for translating LTL->BA')
    gr.add_argument('--ltl3ba',
                    action='store_false',
                    default=False,
                    dest='spot',
                    help='use LTL3BA for translating LTL->BA')

    parser.add_argument(
        '--maxK',
        type=int,
        default=0,
        help="reduce liveness to co-reachability (safety)."
        "This sets the upper bound on the number of 'bad' visits."
        "We iterate over increasing k (exact value of k is set heuristically)."
        "(k=0 means no reduction)")

    gr = parser.add_mutually_exclusive_group()
    gr.add_argument(
        '--bound',
        metavar='bound',
        type=int,
        default=32,
        required=False,
        help=
        'upper bound on the size of the model (for unreal this specifies size of env model)'
    )
    gr.add_argument(
        '--size',
        metavar='size',
        type=int,
        default=0,
        required=False,
        help=
        'search the model of this size (for unreal this specifies size of env model)'
    )

    parser.add_argument('--incr',
                        action='store_true',
                        required=False,
                        default=False,
                        help='use incremental solving')
    parser.add_argument('--tmp',
                        action='store_true',
                        required=False,
                        default=False,
                        help='keep temporary smt2 files')
    parser.add_argument('--dot',
                        metavar='dot',
                        type=str,
                        required=False,
                        help='write the output into a dot graph file')
    parser.add_argument('--log',
                        metavar='log',
                        type=str,
                        required=False,
                        default=None,
                        help='name of the log file')
    parser.add_argument(
        '--unreal',
        action='store_true',
        required=False,
        help='simple check of unrealizability: '
        'invert the spec, system type, (in/out)puts, '
        'and synthesize the model for env '
        '(note that the inverted spec will NOT be strengthened)')
    parser.add_argument('-v', '--verbose', action='count', default=0)

    args = parser.parse_args()

    setup_logging(args.verbose, args.log)
    logging.info(args)

    if args.incr and args.tmp:
        logging.warning(
            "--tmp --incr: incremental queries do not produce smt2 files, "
            "so I won't save any temporal files.")

    with tempfile.NamedTemporaryFile(dir='./') as smt_file:
        smt_files_prefix = smt_file.name

    ltl_to_automaton = (translator_via_ltl3ba.LTLToAtmViaLTL3BA,
                        translator_via_spot.LTLToAtmViaSpot)[args.spot]()
    solver_factory = Z3SolverFactory(smt_files_prefix, Z3_PATH, args.incr,
                                     False, not args.tmp)

    if args.size == 0:
        min_size, max_size = 1, args.bound
    else:
        min_size, max_size = args.size, args.size

    ltl_text, part_text, is_moore = convert_tlsf_or_acacia_to_acacia(
        args.spec, args.moore)

    if args.unreal:
        model = check_unreal(ltl_text, part_text, is_moore, ltl_to_automaton,
                             solver_factory.create(), args.maxK, min_size,
                             max_size)
    else:
        model = check_real(ltl_text, part_text, is_moore, ltl_to_automaton,
                           solver_factory.create(), args.maxK, min_size,
                           max_size)

    if not model:
        logging.info('model NOT FOUND')
    else:
        logging.info('FOUND model for {who} of size {size}'.format(
            who=('sys', 'env')[args.unreal], size=len(model.states)))

    if model:
        dot_model_str = lts_to_dot(model, ARG_MODEL_STATE,
                                   (not is_moore) ^ args.unreal)
        if args.dot:
            with open(args.dot, 'w') as out:
                out.write(dot_model_str)
                logging.info('{model_type} model is written to {file}'.format(
                    model_type=['Mealy', 'Moore'][is_moore], file=out.name))
        else:
            logging.info(dot_model_str)

    solver_factory.down_solvers()

    return UNKNOWN_RC if model is None else (REALIZABLE_RC,
                                             UNREALIZABLE_RC)[args.unreal]
示例#11
0
文件: bosy.py 项目: 5nizza/Party
    group_bound = parser.add_mutually_exclusive_group()
    group_bound.add_argument('--bound', metavar='bound', type=int, default=128, required=False,
                             help='upper bound on the size of local process (default: %(default)i)')
    group_bound.add_argument('--size', metavar='size', type=int, default=0, required=False,
                             help='exact size of the process implementation(default: %(default)i)')

    parser.add_argument('--tmp', action='store_true', required=False, default=False,
                        help='keep temporary smt2 files')
    parser.add_argument('--incr', action='store_true', required=False, default=False,
                        help='produce incremental queries')
    parser.add_argument('-v', '--verbose', action='count', default=0)

    args = parser.parse_args(sys.argv[1:])

    logger = setup_logging(args.verbose)

    logger.info(args)

    with tempfile.NamedTemporaryFile(dir='./') as smt_file:
        smt_files_prefix = smt_file.name

    logic = UFLIA(None)
    ltl2ucw_converter, solver_factory = create_spec_converter_z3(logger, logic, args.incr, smt_files_prefix)
    if not ltl2ucw_converter or not solver_factory:
        exit(1)

    bounds = list(range(1, args.bound + 1) if args.size == 0 else range(args.size, args.size + 1))

    ltl_text = args.ltl.read()
示例#12
0
def main():
    """ :return: 1 if model is found, 0 otherwise """
    parser = argparse.ArgumentParser(
        description='Bounded Synthesizer for CTL*',
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)

    parser.add_argument('spec',
                        metavar='spec',
                        type=str,
                        help='the specification file (in python format)')

    group = parser.add_mutually_exclusive_group()
    group.add_argument(
        '--bound',
        metavar='bound',
        type=int,
        default=128,
        required=False,
        help=
        'upper bound on the size of the model (for unreal this specifies size of env model)'
    )
    group.add_argument(
        '--size',
        metavar='size',
        type=int,
        default=0,
        required=False,
        help=
        'search the model of this size (for unreal this specifies size of env model)'
    )

    group = parser.add_mutually_exclusive_group()
    group.add_argument('--direct',
                       action='store_true',
                       default=True,
                       dest='direct',
                       help='use direct encoding')
    group.add_argument('--aht',
                       action='store_false',
                       default=False,
                       dest='direct',
                       help='encode via AHT')

    parser.add_argument('--incr',
                        action='store_true',
                        required=False,
                        default=False,
                        help='use incremental solving')
    parser.add_argument('--tmp',
                        action='store_true',
                        required=False,
                        default=False,
                        help='keep temporary smt2 files')
    parser.add_argument('--dot',
                        metavar='dot',
                        type=str,
                        required=False,
                        help='write the output into a dot graph file')
    parser.add_argument('--aiger',
                        metavar='aiger',
                        type=str,
                        required=False,
                        help='write the output into an AIGER format')
    parser.add_argument('--log',
                        metavar='log',
                        type=str,
                        required=False,
                        default=None,
                        help='name of the log file')
    parser.add_argument('-v', '--verbose', action='count', default=0)

    args = parser.parse_args()

    setup_logging(args.verbose, args.log)
    logging.info(args)

    if args.incr and args.tmp:
        logging.warning(
            "--tmp --incr: incremental queries do not produce smt2 files, "
            "so I won't save any temporal files.")

    with tempfile.NamedTemporaryFile(dir='./') as smt_file:
        smt_files_prefix = smt_file.name

    ltl_to_atm = translator_via_spot.LTLToAtmViaSpot()
    solver_factory = Z3SolverFactory(smt_files_prefix, Z3_PATH, args.incr,
                                     False, not args.tmp)

    if args.size == 0:
        min_size, max_size = 1, args.bound
    else:
        min_size, max_size = args.size, args.size

    spec = parse_python_spec(args.spec)
    model = check_real(spec, min_size, max_size, ltl_to_atm, solver_factory,
                       args.direct)

    logging.info('{status} model for {who}'.format(
        status=('FOUND', 'NOT FOUND')[model is None], who='sys'))
    if model:
        dot_model_str = lts_to_dot(model, ARG_MODEL_STATE, False)

        if args.dot:
            with open(args.dot, 'w') as out:
                out.write(dot_model_str)
                logging.info(
                    'Moore model is written to {file}'.format(file=out.name))
        else:
            logging.info(dot_model_str)

        if args.aiger:
            with open(args.aiger, 'w') as aiger_out:
                aiger_out.write(lts_to_aiger(model))

    solver_factory.down_solvers()

    return UNKNOWN if model is None else REALIZABLE
示例#13
0

if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="elli trained for syntcomp rally", formatter_class=argparse.ArgumentDefaultsHelpFormatter
    )

    parser.add_argument("spec", metavar="spec", type=str, help="tlsf spec file")
    parser.add_argument(
        "-o",
        "--output",
        metavar="output",
        type=str,
        help="output file for a model in the aiger format (if not given -- print to stdout)",
    )

    parser.add_argument("--dot", metavar="dot", type=str, help="write the output into a dot graph file")
    parser.add_argument("--tmp", action="store_true", default=False, help="keep temporary smt2 files")
    parser.add_argument("-v", "--verbose", action="count", default=-1, help="verbosity level")

    args = parser.parse_args()

    setup_logging(args.verbose)
    logging.info(args)

    with tempfile.NamedTemporaryFile(dir="./") as smt_file:
        smt_files_prefix = smt_file.name

    status = main(args.spec, args.output, args.dot, smt_files_prefix, args.tmp)
    exit(status)