def get_controller_info(self, world_ts: Typeset = None) -> SynthesisInfo:
"""Extract All Info Needed to Build a Controller from the Contract"""
if world_ts is None:
world_ts = Typeset()
"""Assumptions"""
a_initial: List[str] = []
a_fairness: List[str] = []
a_safety: List[str] = []
a_mutex: List[str] = []
"""Guarantees"""
g_initial: List[str] = []
g_safety: List[str] = []
g_mutex: List[str] = []
g_goal: List[str] = []
a_typeset = Typeset()
g_typeset = Typeset()
list, typeset = self.assumptions.formula(FormulaOutput.ListCNF)
a_initial.extend(list)
a_typeset |= typeset
list, typeset = self.guarantees.formula(FormulaOutput.ListCNF)
g_goal.extend(list)
g_typeset |= typeset
all_typeset = a_typeset | g_typeset | world_ts
"""Inputs typeset"""
i_typeset = Typeset(all_typeset.extract_inputs())
"""Output typeset"""
o_typeset = Typeset(all_typeset.extract_outputs())
actions_typeset = Typeset(all_typeset.ext())
"""Mutex"""
ret = Atom.extract_mutex_rules(i_typeset, output=FormulaOutput.ListCNF)
if ret is not None:
rules, typeset = ret
a_mutex.extend(rules)
ret = Atom.extract_mutex_rules(o_typeset, output=FormulaOutput.ListCNF)
if ret is not None:
rules, typeset = ret
g_mutex.extend(rules)
"""For the rules we extracts rules from the variables based on assumptions and inputs"""
a_typeset = a_typeset | i_typeset
"""We remove the inputs typeset from the guarantees and we incorporate the variables ts"""
g_typeset = g_typeset - i_typeset
"""Adding Mutex Rules"""
ret = Atom.extract_mutex_rules(a_typeset, output=FormulaOutput.ListCNF)
if ret is not None:
rules, typeset = ret
a_mutex.extend(rules)
a_typeset |= typeset
ret = Atom.extract_mutex_rules(g_typeset, output=FormulaOutput.ListCNF)
if ret is not None:
rules, typeset = ret
g_mutex.extend(rules)
g_typeset |= typeset
"""Adjacecy rules can include things that are in the world_ts"""
if world_ts is not None:
adjacency_ts = g_typeset | world_ts
else:
adjacency_ts = g_typeset
ret = Atom.extract_adjacency_rules(adjacency_ts,
output=FormulaOutput.ListCNF)
if ret is not None:
rules, typeset = ret
g_adjacency.extend(rules)
g_typeset |= typeset
"""Adding Liveness To Sensors (input)"""
ret = Atom.extract_liveness_rules(i_typeset,
output=FormulaOutput.ListCNF)
if ret is not None:
rules, typeset = ret
a_liveness.extend(rules)
"""Extract Inputs and Outputs"""
inputs = [t.name for t in (a_typeset | g_typeset).extract_inputs()]
outputs = [t.name for t in (a_typeset | g_typeset).extract_outputs()]
return SynthesisInfo(a_initial=assumptions,
a_fairness=a_liveness,
a_mutex=a_mutex,
guarantees=guarantees,
g_mutex=g_mutex,
g_safety=g_adjacency,
inputs=inputs,
outputs=outputs)
def get_controller_info(self, world_ts: Typeset = None) -> SynthesisInfo:
"""Extract All Info Needed to Build a Controller from the Contract"""
"""Assumptions"""
assumptions = []
a_mutex = []
a_liveness = []
"""Guarantees"""
guarantees = []
g_mutex = []
g_adjacency = []
a_typeset = Typeset()
g_typeset = Typeset()
list, typeset = self.assumptions.formula(FormulaOutput.ListCNF)
assumptions.extend(list)
a_typeset |= typeset
list, typeset = self.guarantees.formula(FormulaOutput.ListCNF)
guarantees.extend(list)
g_typeset |= typeset
if world_ts is not None:
instance_ts = Typeset.get_instance_ts((a_typeset | g_typeset), world_ts)
else:
instance_ts = (a_typeset | g_typeset)
"""Extracting Inputs and Outputs Including the variables"""
i_set, o_set = instance_ts.extract_inputs_outputs()
i_typeset = Typeset(i_set)
o_typeset = Typeset(o_set)
"""Mutex Rules"""
ret = Atom.extract_mutex_rules(i_typeset, output=FormulaOutput.ListCNF)
if ret is not None:
rules, typeset = ret
a_mutex.extend(rules)
ret = Atom.extract_mutex_rules(o_typeset, output=FormulaOutput.ListCNF)
if ret is not None:
rules, typeset = ret
g_mutex.extend(rules)
"""Adjacecy Rules"""
ret = Atom.extract_adjacency_rules(o_typeset, output=FormulaOutput.ListCNF)
if ret is not None:
rules, typeset = ret
g_adjacency.extend(rules)
"""Adding Liveness To Sensors (input)"""
ret = Atom.extract_liveness_rules(i_typeset, output=FormulaOutput.ListCNF)
if ret is not None:
rules, typeset = ret
a_liveness.extend(rules)
"""Adding context and active signal rules"""
ret = Atom.context_active_rules(i_typeset, output=FormulaOutput.ListCNF)
if ret is not None:
rules, typeset = ret
assumptions.extend(rules)
"""Extract Inputs and Outputs"""
inputs = [t.name for t in i_set]
outputs = [t.name for t in o_set]
return SynthesisInfo(assumptions=assumptions,
a_liveness=a_liveness,
a_mutex=a_mutex,
guarantees=guarantees,
g_mutex=g_mutex,
g_adjacency=g_adjacency,
inputs=inputs,
outputs=outputs)