def test_find_atomics(self):
a = Symbol("a")
b = Symbol("b")
c = Symbol("c")
atomic_a = AtomicFormula(a)
atomic_b = AtomicFormula(b)
atomic_c = AtomicFormula(c)
self.assertEqual(
PL.find_atomics(And(atomic_a, And(atomic_b, atomic_c))),
{atomic_a, atomic_b, atomic_c})
self.assertEqual(PL.find_atomics(Or(atomic_a, Or(atomic_b, atomic_c))),
{atomic_a, atomic_b, atomic_c})
self.assertEqual(
PL.find_atomics(Equivalence(atomic_a, Or(atomic_b, atomic_c))),
{atomic_a, atomic_b, atomic_c})
def to_nfa(self, f: Formula):
# TODO: optimize!!!
assert self.is_formula(f)
nnf_f = self.to_nnf(f)
alphabet = powerset(self.alphabet.symbols)
initial_states = {frozenset([nnf_f])}
final_states = {frozenset()}
delta = set()
pl, I = PL._from_set_of_propositionals(set(), Alphabet(set()))
d = self.delta(nnf_f, frozenset(), epsilon=True)
if pl.truth(d, I):
final_states.add(frozenset([nnf_f]))
states = {frozenset(), frozenset([nnf_f])}
states_changed, delta_changed = True, True
while states_changed or delta_changed:
states_changed, delta_changed = False, False
for actions_set in alphabet:
states_list = list(states)
for q in states_list:
delta_formulas = [
self.delta(subf, actions_set) for subf in q
]
atomics = [
s for subf in delta_formulas
for s in PL.find_atomics(subf)
]
symbol2formula = {
Symbol(str(f)): f
for f in atomics
if f != TrueFormula() and f != FalseFormula()
}
formula2atomic_formulas = {
f: AtomicFormula.fromName(str(f))
if f != TrueFormula() and f != FalseFormula() else f
for f in atomics
}
transformed_delta_formulas = [
self._tranform_delta(f, formula2atomic_formulas)
for f in delta_formulas
]
conjunctions = And.chain(transformed_delta_formulas)
models = frozenset(
PL(Alphabet(
set(symbol2formula))).minimal_models(conjunctions))
if len(models) == 0:
continue
for min_model in models:
q_prime = frozenset({
symbol2formula[s]
for s in min_model.symbol2truth
if min_model.symbol2truth[s]
})
len_before = len(states)
states.add(q_prime)
if len(states) == len_before + 1:
states_list.append(q_prime)
states_changed = True
len_before = len(delta)
delta.add((q, actions_set, q_prime))
if len(delta) == len_before + 1:
delta_changed = True
# check if q_prime should be added as final state
if len(q_prime) == 0:
final_states.add(q_prime)
else:
q_prime_delta_conjunction = And.chain([
self.delta(subf, frozenset(), epsilon=True)
for subf in q_prime
])
pl, I = PL._from_set_of_propositionals(
set(), Alphabet(set()))
if pl.truth(q_prime_delta_conjunction, I):
final_states.add(q_prime)
return {
"alphabet": alphabet,
"states": frozenset(states),
"initial_states": frozenset(initial_states),
"transitions": delta,
"accepting_states": frozenset(final_states)
}
