def replace_relaxation_action(
prog: syntax.Program,
new_relax_action: syntax.DefinitionDecl) -> syntax.Program:
old_relaxation_action = prog.scope.get('decrease_domain')
decls = [decl for decl in prog.decls if decl != old_relaxation_action]
decls.append(new_relax_action)
return syntax.Program(decls)
def relaxed_program(prog: syntax.Program) -> syntax.Program:
new_decls: List[syntax.Decl] = [d for d in prog.sorts()]
actives: Dict[syntax.SortDecl, syntax.RelationDecl] = {}
for sort in prog.sorts():
name = prog.scope.fresh('active_' + sort.name)
r = syntax.RelationDecl(name, arity=[syntax.UninterpretedSort(sort.name)],
mutable=True, derived=None, annotations=[])
actives[sort] = r
new_decls.append(r)
# active relations initial conditions: always true
for sort in prog.sorts():
name = prog.scope.fresh(sort.name[0].upper())
expr = syntax.Forall([syntax.SortedVar(name, None)],
syntax.Apply(actives[sort].name, [syntax.Id(name)]))
new_decls.append(syntax.InitDecl(name=None, expr=expr))
for d in prog.decls:
if isinstance(d, syntax.SortDecl):
pass # already included above
elif isinstance(d, syntax.RelationDecl):
if d.derived_axiom is not None:
expr = syntax.relativize_quantifiers(actives, d.derived_axiom)
new_decls.append(syntax.RelationDecl(d.name, d.arity, d.mutable, expr,
d.annotations))
else:
new_decls.append(d)
elif isinstance(d, syntax.ConstantDecl):
new_decls.append(d)
elif isinstance(d, syntax.FunctionDecl):
new_decls.append(d)
elif isinstance(d, syntax.AxiomDecl):
new_decls.append(d)
elif isinstance(d, syntax.InitDecl):
new_decls.append(d)
elif isinstance(d, syntax.DefinitionDecl):
assert not isinstance(d.body, syntax.BlockStatement), \
"relax does not support transitions written in imperative syntax"
mods, expr = d.body
expr = syntax.relativize_quantifiers(actives, expr)
if d.is_public_transition:
guard = syntax.relativization_guard_for_binder(actives, d.binder)
expr = syntax.And(guard, expr)
new_decls.append(syntax.DefinitionDecl(d.is_public_transition, d.num_states, d.name,
params=d.binder.vs, body=(mods, expr)))
elif isinstance(d, syntax.InvariantDecl):
expr = syntax.relativize_quantifiers(actives, d.expr)
new_decls.append(syntax.InvariantDecl(d.name, expr=expr,
is_safety=d.is_safety, is_sketch=d.is_sketch))
else:
assert False, d
new_decls.append(relaxation_action_def(prog, actives=actives, fresh=True))
res = syntax.Program(new_decls)
res.resolve() # #sorrynotsorry
return res
def check_program(self, program):
# Check that data declaration LHSs are well-formed.
for decl in program.data_declarations:
self.check_data_declaration_lhs(decl)
# Check that data declaration RHSs are well-formed.
for decl in program.data_declarations:
self.check_data_declaration_rhs(decl)
# Check the expression of the main program
t_body, e_body = self.check_expr(program.body)
return syntax.Program(
data_declarations=program.data_declarations,
body=e_body,
position=program.position,
)
def parse_program(self):
position = self.current_position()
self.match(token.BEGIN)
data_declarations = []
value_declarations = []
while self._token.type() == token.DELIM:
self.match(token.DELIM)
for decl in self.parse_toplevel_declaration():
if decl.is_data_declaration():
data_declarations.append(decl)
else:
value_declarations.append(decl)
self.match(token.END)
self.match(token.EOF)
return syntax.Program(
data_declarations=data_declarations,
body=syntax.Let(declarations=value_declarations,
body=syntax.Variable(name="main",
position=position),
position=position),
position=position,
)
def p_program(p: Any) -> None:
'program : decls'
p[0] = syntax.Program(p[1])
def p_program(p: Any) -> None:
'program : decls'
decls: List[syntax.Decl] = p[1]
p[0] = syntax.Program(decls)
def relaxed_program(prog: syntax.Program) -> syntax.Program:
new_decls: List[syntax.Decl] = [d for d in prog.sorts()]
actives: Dict[syntax.SortDecl, syntax.RelationDecl] = {}
for sort in prog.sorts():
name = prog.scope.fresh('active_' + sort.name)
r = syntax.RelationDecl(name,
arity=(syntax.UninterpretedSort(sort.name), ),
mutable=True)
actives[sort] = r
new_decls.append(r)
# active relations initial conditions: always true
for sort in prog.sorts():
name = prog.scope.fresh(sort.name[0].upper())
expr = syntax.Forall((syntax.SortedVar(name, None), ),
syntax.Apply(actives[sort].name,
(syntax.Id(name), )))
new_decls.append(syntax.InitDecl(name=None, expr=expr))
for d in prog.decls:
if isinstance(d, syntax.SortDecl):
pass # already included above
elif isinstance(d, syntax.RelationDecl):
if d.derived_axiom is not None:
expr = syntax.relativize_quantifiers(actives, d.derived_axiom)
new_decls.append(
syntax.RelationDecl(d.name,
d.arity,
d.mutable,
expr,
annotations=d.annotations))
else:
new_decls.append(d)
elif isinstance(d, syntax.ConstantDecl):
new_decls.append(d)
elif isinstance(d, syntax.FunctionDecl):
new_decls.append(d)
elif isinstance(d, syntax.AxiomDecl):
new_decls.append(d)
elif isinstance(d, syntax.InitDecl):
new_decls.append(d)
elif isinstance(d, syntax.DefinitionDecl):
relativized_def = relativize_decl(d,
actives,
prog.scope,
inline_relax_actives=False)
new_decls.append(relativized_def)
elif isinstance(d, syntax.InvariantDecl):
expr = syntax.relativize_quantifiers(actives, d.expr)
new_decls.append(
syntax.InvariantDecl(d.name,
expr=expr,
is_safety=d.is_safety,
is_sketch=d.is_sketch))
else:
assert False, d
new_decls.append(relaxation_action_def(prog, actives=actives, fresh=True))
res = syntax.Program(new_decls)
typechecker.typecheck_program(res) # #sorrynotsorry
return res
