Пример #1
0
def simplify_facts(db, facts, vars_to_keep):
    assert isinstance(facts, list), facts
    assert all(isinstance(f, Expression) for f in facts), facts
    assert isinstance(vars_to_keep, set), vars_to_keep
    assert all(isinstance(v, Expression) for v in vars_to_keep), vars_to_keep
    assert all(v.is_var() for v in vars_to_keep), vars_to_keep
    facts = set(simplify_expr(f) for f in facts)
    facts = simplify_defs(facts, vars_to_keep)
    strings = db.simplify([f.polish for f in facts])
    facts = set(parse_string_to_expr(s) for s in strings)
    facts = map(unguard_vars, facts)
    return facts
Пример #2
0
def compile_solver(expr, theory):
    '''
    Produces a set of programs that finds values of term satisfying a theory.
    Inputs:
        expr - string, an expression with free variables
        theory - string representing a theory (in .theory format)
    Outputs:
        a program to be consumed by the virtual machine
    Example:
        expr = 's'
        theory = """
            # 6 constraints = 4 facts + 2 rules
            LESS APP V s s       NLESS x BOT      NLESS x I
            LESS APP s BOT BOT   --------------   ----------------
            EQUAL APP s I I      LESS I APP s x   LESS TOP APP s x
            LESS TOP APP s TOP
            """
    '''
    assert isinstance(expr, basestring), expr
    assert isinstance(theory, basestring), theory
    expr = desugar_expr(parse_string_to_expr(expr))
    assert expr.vars, expr
    theory = parse_theory_string(theory)
    facts = map(desugar_expr, theory['facts'])
    rules = map(desugar_sequent, theory['rules'])
    sequents = []
    can_infer_necessary = not rules and all(f.vars <= expr.vars for f in facts)
    can_infer_possible = expr.is_var()  # TODO generalize to injective exprs
    if can_infer_necessary:
        sequents.append(Sequent(facts, [NONEGATE(RETURN(expr))]))
    if can_infer_possible:
        fail = NONEGATE(NRETURN(expr))
        sequents += [Sequent([], [f, fail]) for f in facts]
        sequents += [
            Sequent(r.antecedents, set_with(r.succedents, fail))
            for r in rules
        ]
    assert sequents, 'Cannot infer anything'
    programs = []
    write_full_programs(programs, sequents, can_parallelize=False)
    program = '\n'.join(programs)
    assert not re.search('FOR_BLOCK', program), 'cannot parallelize'
    return program
Пример #3
0
def parse_expr(string):
    return desugar_expr(parse_string_to_expr(string))
Пример #4
0
def pythonize_expr(proto_expr):
    return parse_string_to_expr(proto_expr.polish)
Пример #5
0
def desugar(string):
    expr = parse_string_to_expr(string)
    expr = desugar_expr(expr)
    expr = guard_vars(expr)
    return str(expr)
Пример #6
0
def test_hole_filler_increases_complexity(example):
    term = parse_string_to_expr(example[0])
    fillings = list(fill_holes(term))
    for f in fillings:
        assert evaluate_complexity(term) < evaluate_complexity(f)
Пример #7
0
def test_hole_filler(example):
    term = parse_string_to_expr(example[0])
    expected = map(parse_string_to_expr, example[1])
    actual = list(fill_holes(term))
    assert actual == expected
Пример #8
0
def test_complexity_evaluator(example):
    term = parse_string_to_expr(example)
    assert 0 < evaluate_complexity(term)
Пример #9
0
def _db_simplify_expr(db, expr):
    string = db.simplify([expr.polish])[0]
    expr = parse_string_to_expr(string)
    expr = unguard_vars(expr)
    return expr