def extract_mutex_rules(typeset: Typeset, output=None) -> Union[Atom, Tuple[List[str], Typeset]]:
"""Extract Mutex rules from the Formula"""
rules_str = []
rules_typeset = Typeset()
for mutex_group in typeset.mutex_types:
or_elements = []
if len(mutex_group) > 1:
for mutex_type in mutex_group:
neg_group = mutex_group.symmetric_difference({mutex_type})
and_elements = [mutex_type.name]
for elem in neg_group:
and_elements.append(Logic.not_(elem.name))
or_elements.append(Logic.and_(and_elements, brackets=True))
rules_str.append(Logic.g_(Logic.or_(or_elements, brackets=False)))
rules_typeset |= Typeset(mutex_group)
if len(rules_str) == 0:
return None
if output is not None and output == FormulaOutput.ListCNF:
return rules_str, rules_typeset
return Atom(formula=(Logic.and_(rules_str, brackets=True), rules_typeset), kind=AtomKind.MUTEX_RULE)
def context_active_rules(typeset: Typeset, output=None) -> Union[Atom, Tuple[List[str], Typeset]]:
"""Extract Liveness rules from the Formula"""
rules_str = []
rules_typeset = Typeset()
inputs, outs = typeset.extract_inputs_outputs()
active_context_types = []
for t in inputs:
if isinstance(t, Boolean):
if t.kind == TypeKinds.ACTIVE or t.kind == TypeKinds.CONTEXT:
active_context_types.append(t.name)
rules_typeset |= Typeset({t})
if len(active_context_types) > 0:
rules_str.append(Logic.g_(Logic.and_(active_context_types)))
if len(rules_str) == 0:
return None
if output is not None and output == FormulaOutput.ListCNF:
return rules_str, rules_typeset
return Atom(formula=(Logic.and_(rules_str, brackets=True), rules_typeset), kind=AtomKind.LIVENESS_RULE)
def __init__(self, ls: Union[List[Atom], List[Boolean]] = None):
new_typeset, loc = CoreMovement.process_input(ls)
f = []
for l in loc:
f.append(Logic.gf_(l))
super().__init__(formula=(Logic.and_(f), new_typeset))
def __init__(self, pre: Union[Specification, Boolean],
post: Union[Specification, Boolean]):
new_typeset, pre, post = Trigger.process_bin_input(pre, post)
f = Logic.g_(Logic.implies_(pre, Logic.u_(pre, post)))
super().__init__(formula=(f, new_typeset))
def __init__(self, pre: Union[Atom, Boolean],
post: Union[Atom, Boolean],
active: Union[Atom, Boolean],
context: Union[Atom, Boolean] = None):
new_typeset, pre, post, context, active = Trigger.process_bin_contextual_input(pre, post, context, active)
c = Logic.and_([context, active])
f = Logic.g_(Logic.iff_(Logic.and_([c, pre]), Logic.and_([c, post])))
super().__init__(formula=(f, new_typeset))
def __init__(self,
ls: Union[Atom, Boolean, List[Atom], List[Boolean]] = None):
new_typeset, loc = CoreMovement.process_input(ls)
f = []
"""F(l1), F(l2), ...,F(ln)"""
for l in loc:
f.append(L.f_(l))
"""F(l1) & F(l2) & ... & F(ln)"""
new_formula = L.and_(f)
super().__init__(formula=(new_formula, new_typeset))
def __init__(self, supertypes: Dict[AllTypes, Set[AllTypes]]):
super().__init__(atom=Atom("TRUE"), kind=FormulaKind.REFINEMENT_RULES)
for key_type, set_super_types in supertypes.items():
if isinstance(key_type, Boolean):
for super_type in set_super_types:
f = Logic.g_(Logic.implies_(key_type.name,
super_type.name))
t = Typeset({key_type, super_type})
new_atom = Atom(formula=(f, t),
kind=AtomKind.REFINEMENT_RULE)
self.__iand__(new_atom)
def formula(
self,
formulatype: FormulaOutput = FormulaOutput.CNF
) -> Union[Tuple[str, Typeset], Tuple[List[str], Typeset]]:
"""Generate the formula"""
if formulatype == FormulaOutput.CNF:
return LogicTuple.and_([
LogicTuple.or_([atom.formula() for atom in clause],
brakets=True) for clause in self.cnf
],
brackets=False)
if formulatype == FormulaOutput.ListCNF:
return [
Logic.or_([atom.string for atom in clause])
for clause in self.cnf
], self.typeset
if formulatype == FormulaOutput.DNF:
return LogicTuple.or_([
LogicTuple.and_([atom.formula() for atom in clause],
brackets=True) for clause in self.dnf
],
brakets=False)
def __init__(self,
pre: Union[Atom, Boolean],
ls: Union[Atom, Boolean, List[Atom], List[Boolean]] = None):
new_typeset_a, loc = CoreMovement.process_input(ls)
new_typeset_b, condition = Trigger.process_uni_input(pre)
f = []
"""F(l1), F(l2), ...,F(ln)"""
for l in loc:
f.append(Logic.f_(l))
"""F(l1) & F(l2) & ... & F(ln)"""
new_formula = Logic.g_(Logic.implies_(condition, Logic.and_(f)))
new_typeset = new_typeset_a | new_typeset_b
super().__init__(formula=(new_formula, new_typeset))
def formula(self, type: FormulaType = FormulaType.SATURATED) -> (str, Typeset):
expression, typeset = self.__base_formula
if type == FormulaType.SATURATED:
if self.__saturation is None:
expression, typeset = self.__base_formula
else:
expression, typeset = LogicTuple.implies_(self.__saturation.formula(), self.__base_formula,
brackets=True)
if self.negated:
return Logic.not_(expression), typeset
return expression, typeset
def extract_refinement_rules(typeset: Typeset, output=None) -> Union[Atom, Tuple[List[str], Typeset]]:
"""Extract Refinement rules from the Formula"""
rules_str = []
rules_typeset = Typeset()
for key_type, set_super_types in typeset.super_types.items():
if isinstance(key_type, Boolean):
for super_type in set_super_types:
rules_str.append(Logic.g_(Logic.implies_(key_type.name, super_type.name)))
rules_typeset |= Typeset({key_type})
rules_typeset |= Typeset(set_super_types)
if len(rules_str) == 0:
return None
if output is not None and output == FormulaOutput.ListCNF:
return rules_str, rules_typeset
return Atom(formula=(Logic.and_(rules_str, brackets=True), rules_typeset), kind=AtomKind.MUTEX_RULE)
def create_transition_controller(self, start: Types, finish: Types, t_trans: int) -> Controller:
t_controller_name = f"TRANS_{start.name}->{finish.name}"
if self.session_name is None:
folder_name = f"{self.t_controllers_folder_name}/{t_controller_name}"
else:
folder_name = f"{self.session_name}/{self.t_controllers_folder_name}/{t_controller_name}"
typeset = Typeset({start, finish})
realizable = False
for n_steps in range(1, t_trans):
trans_spec_str = Logic.and_([start.name, Logic.xn_(finish.name, n_steps)])
trans_spec = Atom(formula=(trans_spec_str, typeset))
trans_contract = Contract(guarantees=trans_spec)
try:
controller_info = trans_contract.get_controller_info(world_ts=self.world.typeset)
a, g, i, o = controller_info.get_strix_inputs()
controller_synthesis_input = StringMng.get_controller_synthesis_str(controller_info)
Store.save_to_file(controller_synthesis_input,
f"t_controller_{start.name}_{finish.name}_specs.txt", folder_name)
realized, kiss_mealy, time = Strix.generate_controller(a, g, i, o)
if realized:
realizable = True
break
except ControllerException as e:
raise TransSynthesisFail(self, e)
if not realizable:
raise Exception(
f"Controller [{start.name}, {finish.name}] cannot be synthetized in {t_trans} steps")
else:
Store.save_to_file(kiss_mealy, f"{start.name}_{finish.name}_mealy",
folder_name)
# Store.generate_eps_from_dot(dot_mealy, f"{start.name}_{finish.name}_dot",
# folder_name)
t_controller = Controller(mealy_machine=kiss_mealy, world=self.world, name=t_controller_name,
synth_time=time)
Store.save_to_file(str(t_controller), f"{start.name}_{finish.name}_table", folder_name)
return t_controller
def extract_adjacency_rules(typeset: Typeset, output=None) -> Union[Atom, Tuple[List[str], Typeset]]:
"""Extract Adjacency rules from the Formula"""
rules_str = []
rules_typeset = Typeset()
for key_type, set_adjacent_types in typeset.adjacent_types.items():
if isinstance(key_type, Boolean):
"""G(a -> X(b | c | d))"""
rules_str.append(
Logic.g_(Logic.implies_(key_type.name, Logic.x_(Logic.or_([e.name for e in set_adjacent_types])))))
rules_typeset |= Typeset({key_type})
rules_typeset |= Typeset(set_adjacent_types)
if len(rules_str) == 0:
return None
if output is not None and output == FormulaOutput.ListCNF:
return rules_str, rules_typeset
return Atom(formula=(Logic.and_(rules_str, brackets=True), rules_typeset), kind=AtomKind.ADJACENCY_RULE)
def get_strix_inputs(self) -> Tuple[str, str, str, str]:
a = Logic.and_(list(itertools.chain(
self.__assumptions,
self.__a_mutex,
self.__a_liveness
)))
from tools.strings import StringMng
a = StringMng.strix_syntax_fix(a)
g = Logic.and_(list(itertools.chain(
self.__guarantees,
self.__g_mutex,
self.__g_adjacency
)))
g = StringMng.strix_syntax_fix(g)
i = " ,".join(self.__inputs)
o = " ,".join(self.__outputs)
return a, g, i, o
def check_satisfiability(formula: Tuple[str, Typeset]) -> bool:
expression, typeset = formula
if not isinstance(expression, str) or not isinstance(typeset, Typeset):
raise AttributeError
if expression == "TRUE":
return True
if expression == "FALSE":
return False
variables = Nuxmv.__convert_to_nuxmv(typeset)
"""Write the NuSMV file"""
with open(Nuxmv.smvfile, 'w') as ofile:
ofile.write('MODULE main\n')
ofile.write('VAR\n')
for v in list(set(variables)):
ofile.write(f"\t{v};\n")
ofile.write('\n')
ofile.write('LTLSPEC ')
ofile.write(str(Logic.not_(expression)))
ofile.write('\n')
try:
output = subprocess.check_output(
['nuXmv', Nuxmv.smvfile],
encoding='UTF-8',
stderr=subprocess.DEVNULL).splitlines()
output = [
x for x in output
if not (x[:3] == '***' or x[:7] == 'WARNING' or x == '')
]
for line in output:
if line[:16] == '-- specification':
if 'is false' in line:
print("\t\t\tSAT-YES:\t" + str(expression))
return True
elif 'is true' in line:
print("\t\t\tSAT-NO :\t" + str(expression))
return False
except Exception as e:
with open(Nuxmv.smvfile, 'r') as fin:
print(fin.read())
raise e
def __init__(self,
ls: Union[Atom, Boolean, List[Atom], List[Boolean]] = None):
new_typeset, loc = CoreMovement.process_input(ls)
new_typeset, loc = CoreMovement.process_input(ls)
lor = list(loc)
lor.reverse()
n = len(loc)
f = []
"""F(l1), F(l2), ...,F(ln)"""
for l in loc:
f.append(L.f_(l))
"""F(l1) & F(l2) & ... & F(ln)"""
f1 = L.and_(f)
f2 = []
"""1..n-1 !l_{i+1} U l_{i}"""
for i, l in enumerate(loc[:n - 1]):
f = L.u_(L.not_(loc[i + 1]), loc[i])
f2.append(f)
f2 = L.and_(f2)
new_formula = L.and_([f1, f2])
super().__init__(formula=(new_formula, new_typeset))
def __init__(self, l: Union[Specification, Boolean]):
new_typeset, l = Trigger.process_uni_input(l)
f = Logic.g_(Logic.not_(l))
super().__init__(formula=(f, new_typeset))
def parse_controller_specification_from_file(
file_path: str) -> Tuple[str, str, str, str]:
"""Returns: assumptions, guarantees, inputs, outputs"""
assumptions = []
guarantees = []
inputs = []
outputs = []
file_header = ""
with open(file_path, 'r') as ifile:
for line in ifile:
line, header = StringMng._check_header(line)
# skip empty lines
if not line:
continue
# parse file header line
elif header:
if StringMng.ASSUMPTIONS_HEADER == line:
if file_header == "":
file_header = line
else:
Exception("File format not supported")
elif StringMng.GUARANTEES_HEADER == line:
if file_header == StringMng.ASSUMPTIONS_HEADER:
file_header = line
else:
Exception("File format not supported")
elif StringMng.INS_HEADER == line:
if file_header == StringMng.GUARANTEES_HEADER:
file_header = line
else:
Exception("File format not supported")
elif StringMng.OUTS_HEADER == line:
if file_header == StringMng.INS_HEADER:
file_header = line
else:
Exception("File format not supported")
elif StringMng.END_HEADER == line:
if file_header == StringMng.OUTS_HEADER:
if len(assumptions) == 0:
assumptions.append("true")
return Logic.and_(assumptions), Logic.and_(
guarantees), ",".join(inputs), ",".join(
outputs)
else:
Exception("File format not supported")
else:
raise Exception("Unexpected File Header: " + line)
else:
if StringMng.ASSUMPTIONS_HEADER == file_header:
assumptions.append(line.strip())
if StringMng.GUARANTEES_HEADER == file_header:
guarantees.append(line.strip())
if StringMng.INS_HEADER == file_header:
inputs.append(line.strip())
if StringMng.OUTS_HEADER == file_header:
outputs.append(line.strip())
def __init__(self, ls: Union[List[Atom], List[Boolean]] = None):
new_typeset, loc = CoreMovement.process_input(ls)
lor = list(loc)
lor.reverse()
n = len(loc)
f1 = Logic.f_(lor[0])
if len(ls) == 1:
super().__init__(formula=(Logic.g_(f1), new_typeset))
return
"""GF(l1 & F(l2 & ... F(ln))))"""
for l in lor[1:]:
f2 = Logic.and_([l, f1])
f1 = Logic.f_(f2)
f1 = Logic.g_(f1)
f2 = []
"""1..n-1 !l_{i+1} U l_{i}"""
for i, l in enumerate(loc[:n - 1]):
f = Logic.u_(Logic.not_(loc[i + 1]), loc[i])
f2.append(f)
f2 = Logic.and_(f2)
f3 = []
"""1..n G(l_{(i+1)%n} -> X((!l_{(i+1)%n} U l_{i})))"""
for i, l in enumerate(loc):
f = Logic.g_(
Logic.implies_(
loc[(i + 1) % n],
Logic.x_(Logic.u_(Logic.not_(loc[(i + 1) % n]), loc[i]))))
f3.append(f)
f3 = Logic.and_(f3)
if len(loc) > 2:
f4 = []
"""1..n G(l_{(i+1)%n} -> X((!l_{(i+1)%n} U l_{i})))"""
for i, l in enumerate(loc):
f = Logic.g_(
Logic.implies_(
loc[i],
Logic.x_(Logic.u_(Logic.not_(loc[i]),
loc[(i + 1) % n]))))
f4.append(f)
f4 = Logic.and_(f4)
new_formula = Logic.and_([f1, f2, f3, f4])
else:
new_formula = Logic.and_([f1, f2, f3])
super().__init__(formula=(new_formula, new_typeset))
