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))
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)
f3 = []
"""1..n-1 !l_{i} U l_{i} & X(!l_{i} U l_{i+1})"""
for i, l in enumerate(loc[:n - 1]):
f = L.u_(L.not_(loc[i]),
L.and_([loc[i],
L.x_(L.u_(L.not_(loc[i]), loc[i + 1]))]))
f3.append(f)
f3 = L.and_(f3)
new_formula = L.and_([f1, f2, f3])
super().__init__(formula=(new_formula, 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.x_(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.x_(Logic.w_(Logic.not_(c), Logic.and_([c, post])))))
super().__init__(formula=(f, new_typeset))
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)
