def get_ltl_guarantees(self) -> LTL:
g_list = []
vars = Variables()
for c in self.contracts:
g_list.append(c.guarantees.formula.formula)
vars.extend(c.guarantees.formula.variables)
new_formula = And(g_list)
return LTL(new_formula, vars)
def get_ltl_assumptions(self) -> LTL:
a_list = []
vars = Variables()
for c in self.contracts:
a_list.append(c.assumptions.formula.formula)
vars.extend(c.assumptions.formula.variables)
new_formula = Or(a_list)
return LTL(new_formula, vars)
def get_ltl_saturated_guarantees(self) -> LTL:
assumptions_guarantee_pairs = []
vars = Variables()
for c in self.contracts:
assumptions_guarantee_pairs.append(
(c.assumptions.formula.formula, c.guarantees.formula.formula))
vars.extend(c.assumptions.formula.variables)
vars.extend(c.guarantees.formula.variables)
new_formula = []
for ag_pairs in assumptions_guarantee_pairs:
new_formula.append(Implies(ag_pairs[0], ag_pairs[1]))
new_formula = And(new_formula)
return LTL(new_formula, vars)
def __init__(self, patterns: List[LTL]):
self.patterns = patterns
variables = Variables()
guarantees = []
for p in patterns:
variables.extend(p.variables)
guarantees.append(Guarantee(p.formula, p.variables))
guarantees = Guarantees(guarantees)
super().__init__(guarantees=guarantees)
def __init__(self, formulae: List['LTL'], simplify=True):
"formulae: list of formula to conjoin"
"LTL formula"
self.__formula: LTL = None
"List of LTL formulae in conjunction that it is formed of"
self.__list: List[LTL] = None
if len(formulae) == 0:
self.__formula: LTL = LTL("TRUE")
self.__list: List[LTL] = []
else:
if simplify:
self.__formula: LTL = LTL(formulae[0].formula, formulae[0].variables)
self.__list: List[LTL] = [formulae[0]]
if len(formulae) > 1:
try:
added_formulae = self.__formula.conjoin_with(formulae[1:])
self.list.extend(added_formulae)
except InconsistentException as e:
raise e
else:
variables = Variables()
formulae_str = []
for formula in formulae:
variables.extend(formula.variables)
formulae_str.append(formula.formula)
try:
self.__formula: LTL = LTL(And(formulae_str), variables)
except InconsistentException as e:
raise e
self.__list: List[LTL] = formulae
def generate_general_controller_inputs_from_goal(
ap: dict,
rules: dict,
goal: CGTGoal,
complete=True) -> Tuple[List[str], List[str], List[str], List[str]]:
variables = Variables()
assumptions = []
guarantees = []
"""Adding A/G from the goal"""
a = goal.get_ltl_assumptions().formula
if a != "TRUE":
assumptions.append(a)
g = goal.get_ltl_guarantees().formula
if g != "TRUE":
guarantees.append(g)
variables.extend(goal.get_variables())
"""Adding liveness rules of the environemnt as assumptions"""
liveness_rules = extract_ltl_rules(rules["environment"])
for r in liveness_rules:
variables.extend(r.variables)
assumptions.append(r.formula)
"""Adding domain rules of the robot as guarantees"""
domain_rules = extract_ltl_rules(rules["domain"])
for r in domain_rules:
variables.extend(r.variables)
guarantees.append(r.formula)
"""Adding context rules as assumptions if not already included (cgt includes them)"""
if complete:
context_rules = extract_ltl_rules(rules["context"])
for r in context_rules:
variables.extend(r.variables)
assumptions.append(r.formula)
# """Replacing TRUE with true, for strix"""
# for a in assumptions:
# a.replace("TRUE", "true")
# for g in guarantees:
# g.replace("TRUE", "true")
uncontrollable = []
controllable = []
"""Splitting the variables between uncontrollable and controllable"""
for v in variables.list:
if v.name in ap["s"]:
uncontrollable.append(v.name)
else:
controllable.append(v.name)
return assumptions, guarantees, uncontrollable, controllable
def get_variables(self) -> Variables:
vars = Variables()
for c in self.contracts:
vars.extend(c.guarantees.formula.variables)
vars.extend(c.assumptions.formula.variables)
return vars
