def _build_automata(self):
rows = self.row_symbols
atoms = [AtomicFormula(r) for r in rows]
alphabet = Alphabet(set(rows))
ldlf = LDLf_EmptyTraces(alphabet)
f = PathExpressionEventually(
PathExpressionSequence.chain([
PathExpressionStar(
And.chain([Not(atoms[0]),
Not(atoms[1]),
Not(atoms[2])])),
PathExpressionStar(
And.chain([atoms[0],
Not(atoms[1]),
Not(atoms[2])])),
# Not(atoms[3]), Not(atoms[4]), Not(atoms[5])]),
PathExpressionStar(
And.chain([atoms[0], atoms[1],
Not(atoms[2])])),
# Not(atoms[3]), Not(atoms[4]), Not(atoms[5])]),
# And.chain([atoms[0], atoms[1], atoms[2]]), # Not(atoms[3]), Not(atoms[4]), Not(atoms[5])]),
# And.chain([atoms[0], atoms[1], atoms[2], atoms[3], Not(atoms[4]), Not(atoms[5])]),
# And.chain([atoms[0], atoms[1], atoms[2], atoms[3], atoms[4], Not(atoms[5])]),
# And.chain([atoms[0], atoms[1], atoms[2], atoms[3], atoms[4], atoms[5] ])
]),
And.chain([atoms[0], atoms[1], atoms[2]]))
nfa = ldlf.to_nfa(f)
dfa = _to_pythomata_dfa(nfa)
return dfa
def test_truth_star(self):
ref = self.ref
a = self.a
b = self.b
c = self.c
self.assertTrue(ref.truth(PathExpressionStar(a), self.trace_1, 0, 4))
self.assertFalse(ref.truth(PathExpressionStar(a), self.trace_1, 0, 5))
self.assertTrue(
ref.truth(PathExpressionStar(Or(a, Or(b, c))), self.trace_1, 0, 5))
self.assertTrue(ref.truth(TrueFormula(), self.trace_1, 0, 1))
def test_to_nnf(self):
f1 = Not(
PathExpressionEventually(
PathExpressionSequence(PathExpressionTest(Not(self.a_and_b)),
PathExpressionStar(TrueFormula())),
self.abc))
nnf_f1 = PathExpressionAlways(
PathExpressionSequence(
PathExpressionTest(Or(Not(self.a), Not(self.b))),
# PathExpressionStar(Or(DUMMY_ATOMIC, Not(DUMMY_ATOMIC)))
PathExpressionStar(TrueFormula())),
Or(Not(self.a), Or(Not(self.b), Not(self.c))))
self.assertEqual(self.ldlf.to_nnf(f1), nnf_f1)
def _expand_path(self, p: PathExpression) -> PathExpression:
if isinstance(p, PathExpressionUnion) or isinstance(
p, PathExpressionSequence):
return type(p)(self._expand_path(p.p1), self._expand_path(p.p2))
elif isinstance(p, PathExpressionTest):
return PathExpressionTest(self.expand_formula(p.f))
elif isinstance(p, PathExpressionStar):
return PathExpressionStar(self._expand_path(p.p))
elif isinstance(p, Formula):
pl = PL(self.alphabet)
return pl.expand_formula(p)
else:
raise ValueError
def to_nnf(self, f: Formula):
if isinstance(f, PathExpressionUnion):
return PathExpressionUnion(self.to_nnf(f.p1), self.to_nnf(f.p2))
elif isinstance(f, PathExpressionSequence):
return PathExpressionSequence(self.to_nnf(f.p1), self.to_nnf(f.p2))
elif isinstance(f, PathExpressionStar):
return PathExpressionStar(self.to_nnf(f.p))
elif isinstance(f, Formula):
pl = PL(self.alphabet)
assert pl.is_formula(f)
return f
else:
raise ValueError
def to_nnf_path(self, path: PathExpression):
if isinstance(path, PathExpressionTest):
return PathExpressionTest(self.to_nnf(path.f))
elif isinstance(path, PathExpressionUnion):
return PathExpressionUnion(self.to_nnf_path(path.p1), self.to_nnf_path(path.p2))
elif isinstance(path, PathExpressionSequence):
return PathExpressionSequence(self.to_nnf_path(path.p1), self.to_nnf_path(path.p2))
elif isinstance(path, PathExpressionStar):
return PathExpressionStar(self.to_nnf_path(path.p))
elif isinstance(path, Formula):
pl = PL(self.alphabet)
assert pl.is_formula(path)
return pl.to_nnf(path)
else:
raise ValueError
def to_equivalent_formula(self, derived_formula: Formula):
# make lines shorter
ef = self.to_equivalent_formula
if isinstance(derived_formula, AtomicFormula):
return PathExpressionEventually(derived_formula, LogicalTrue())
elif isinstance(derived_formula, LogicalFalse):
return Not(LogicalTrue())
elif isinstance(derived_formula, Or):
return Not(And(Not(derived_formula.f1), Not(derived_formula.f2)))
elif isinstance(derived_formula, PathExpressionAlways):
return Not(
PathExpressionEventually(derived_formula.p,
Not(derived_formula.f)))
elif isinstance(derived_formula, Next):
return PathExpressionEventually(
TrueFormula(), And(derived_formula.f, Not(ef(End()))))
elif isinstance(derived_formula, End):
return ef(PathExpressionAlways(TrueFormula(), ef(LogicalFalse())))
elif isinstance(derived_formula, Until):
return PathExpressionEventually(
PathExpressionStar(
PathExpressionSequence(
PathExpressionTest(derived_formula.f1),
ef(TrueFormula()))),
And(derived_formula.f2, Not(ef(End()))))
elif isinstance(derived_formula, FalseFormula):
return FalseFormula()
elif isinstance(derived_formula, TrueFormula):
return TrueFormula()
elif isinstance(derived_formula, LDLfLast):
return PathExpressionEventually(ef(TrueFormula()), ef(End()))
# propositional
elif isinstance(derived_formula, Formula):
pl = PL(self.alphabet)
assert pl.is_formula(derived_formula)
f = pl.to_nnf(derived_formula)
return PathExpressionEventually(f, LogicalTrue())
else:
raise ValueError("Derived formula not recognized")
def setUp(self):
"""Set up test fixtures, if any."""
# Symbols
self.a_sym = Symbol("a")
self.b_sym = Symbol("b")
self.c_sym = Symbol("c")
# Propositions
self.a = AtomicFormula(self.a_sym)
self.b = AtomicFormula(self.b_sym)
self.c = AtomicFormula(self.c_sym)
# Propositionals
self.not_a = Not(self.a)
self.not_b = Not(self.b)
self.not_c = Not(self.c)
self.a_and_b = And(self.a, self.b)
self.a_and_c = And(self.a, self.c)
self.b_and_c = And(self.b, self.c)
self.abc = And(self.a, And(self.b, self.c))
self.b_or_c = Or(self.b, self.c)
self.a_or_b = Or(self.a, self.b)
self.not_abc = Not(And(self.a, And(self.b, self.c)))
### Path expression
# Tests
self.test_a = PathExpressionTest(self.a)
self.test_b = PathExpressionTest(self.b)
self.test_not_a = PathExpressionTest(self.not_a)
self.test_not_b = PathExpressionTest(self.not_b)
# Union
self.path_a_or_b = PathExpressionUnion(self.a, self.b)
self.path_b_or_c = PathExpressionUnion(self.b, self.c)
# Sequence
self.path_seq_a_and_b__a_and_c = PathExpressionSequence(
self.a_and_b, self.a_and_c)
self.path_a_or_b__b_or_c = PathExpressionSequence(
self.path_a_or_b, self.path_b_or_c)
# Stars
self.path_b_or_c_star = PathExpressionStar(self.path_b_or_c)
self.path_not_abc = PathExpressionStar(self.not_abc)
# Modal connective
self.eventually_propositional_a_and_b__a_and_c = PathExpressionEventually(
self.a_and_b, self.a_and_c)
self.eventually_test_a__c = PathExpressionEventually(
self.test_a, self.c)
self.eventually_test_a__b = PathExpressionEventually(
self.test_a, self.b)
self.eventually_seq_a_and_b__a_and_c__not_c = PathExpressionEventually(
self.path_seq_a_and_b__a_and_c, self.not_c)
self.eventually_seq_a_and_b__a_and_c__c = PathExpressionEventually(
self.path_seq_a_and_b__a_and_c, self.c)
self.eventually_b_or_c_star__b_and_c = PathExpressionEventually(
self.path_b_or_c_star, self.b_and_c)
self.next_a_and_c = PathExpressionEventually(TrueFormula(),
self.a_and_c)
self.liveness_b_and_c = PathExpressionEventually(
PathExpressionStar(TrueFormula()), self.b_and_c)
self.liveness_abc = PathExpressionEventually(
PathExpressionStar(TrueFormula()), self.abc)
self.always_true__a = PathExpressionAlways(
PathExpressionStar(TrueFormula()), self.a)
self.always_true__b_or_c = PathExpressionAlways(
PathExpressionStar(TrueFormula()), self.b_or_c)
self.alphabet = Alphabet({self.a_sym, self.b_sym, self.c_sym})
# Traces
self.ldlf = LDLf(self.alphabet)
self.trace_1_list = [
{self.a_sym, self.b_sym},
{self.a_sym, self.c_sym},
{self.a_sym, self.b_sym},
{self.a_sym, self.c_sym},
{self.b_sym, self.c_sym},
]
self.trace_1 = FiniteTrace(self.trace_1_list, self.alphabet)
def test_star(self):
alphabet = Alphabet.fromStrings({"a"})
a = AtomicFormula.fromName("a")
ref = REf(alphabet)
self.assertTrue(ref.is_formula(PathExpressionStar(a)))