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