def setUp(self):
node_label_def = [{
'name': 'ap',
'values': PowerSet({'p', 'q', 'r', 'x', 'a', 'b'})}]
G = labeled_graphs.LabeledDiGraph(node_label_def)
self.S_ap = labeled_graphs.States(G)
G.states = self.S_ap
def setUp(self):
p = PowerSet({1, 2})
node_labeling = [
{
'name': 'month',
'values': ['Jan', 'Feb']
},
{
'name': 'day',
'values': ['Mon', 'Tue']
},
{
'name': 'comb',
'values': p,
'setter': p.math_set
}
]
edge_labeling = node_labeling
G = labeled_graphs.LabeledDiGraph(node_labeling, edge_labeling)
G.states.add_from({1, 2})
G.transitions.add(1, 2, month='Jan', day='Mon')
assert_raises(Exception, G.transitions.add,
1, 2, {'month': 'Jan', 'day': 'abc'})
# note how untyped keys can be set directly via assignment,
# whereas check=False is needed for G.add_node
G.node[1]['mont'] = 'Feb'
assert(G.node[1] == {'mont':'Feb'})
G[1][2][0]['day'] = 'Tue'
assert(G[1][2][0] == {'month':'Jan', 'day':'Tue'})
self.G = G
def __init__(self):
ap_labels = PowerSet()
node_label_types = [{
'name': 'ap',
'values': ap_labels,
'setter': ap_labels.math_set,
'default': set()
}]
super(KripkeStructure, self).__init__(node_label_types)
self.atomic_propositions = self.ap
# dot formatting
self._state_dot_label_format = {
'ap': '',
'type?label': '',
'separator': r'\\n'
}
self.dot_node_shape = {'normal': 'rectangle'}
self._state_dot_label_format = {
'ap': '',
'type?label': '',
'separator': r'\\n'
}
self._transition_dot_label_format = {
'type?label': ':',
'separator': r'\\n'
}
self._transition_dot_mask = dict()
def ba_test():
ba = trs.BA()
aps = ['p']
ba.atomic_propositions |= {'p'}
assert ('p' in ba.atomic_propositions)
assert (ba.atomic_propositions == MathSet(aps))
assert (ba.alphabet == PowerSet(aps))
ba.states.add_from({'q0', 'q1'})
assert (set(ba.states) == {'q0', 'q1'})
ba.states.initial.add('q0')
assert (set(ba.states.initial) == {'q0'})
ba.states.accepting.add('q1')
assert (set(ba.states.accepting) == {'q1'})
ba.transitions.add('q0', 'q1', letter={'p'})
ba.transitions.add('q1', 'q1', letter={'p'})
ba.transitions.add('q1', 'q0', letter=set())
ba.transitions.add('q0', 'q0', letter=set())
logger.debug(ba)
ba.save('ba.pdf')
return ba
def __init__(
self,
deterministic=False,
accepting_states_type=None,
atomic_proposition_based=True,
symbolic=False,
):
"""Initialize FiniteStateAutomaton.
Additional keyword arguments are passed to L{LabeledDiGraph.__init__}.
@param atomic_proposition_based: If False, then the alphabet
is represented by a set. If True, then the alphabet is
represented by a powerset 2^AP.
"""
self.atomic_proposition_based = atomic_proposition_based
self.symbolic = symbolic
# edge labeling
if symbolic:
alphabet = None # no checks
else:
if atomic_proposition_based:
alphabet = PowerSet([])
self.atomic_propositions = alphabet.math_set
else:
alphabet = set()
self.alphabet = alphabet
edge_label_types = [{
'name': 'letter',
'values': alphabet,
'setter': True
}]
super(FiniteStateAutomaton,
self).__init__(edge_label_types=edge_label_types)
# accepting states
if accepting_states_type is None:
self._accepting = SubSet(self.states)
self._accepting_type = SubSet
else:
self._accepting = accepting_states_type(self)
self._accepting_type = accepting_states_type
self.states.accepting = self._accepting
# used before label value
self._transition_dot_label_format = {
'letter': '',
'type?label': '',
'separator': '\n'
}
self._transition_dot_mask = dict()
self.dot_node_shape = {'normal': 'circle', 'accepting': 'doublecircle'}
self.default_export_fname = 'fsa'
self.automaton_type = 'Finite State Automaton'
def powerset_test():
s = [[1, 2], '3', {'a': 1}, 1]
p = PowerSet(s)
s2 = ['3', {'a': 1}, [1, 2], 1]
q = PowerSet()
q.math_set = MathSet(s2)
assert (p.math_set == MathSet(s))
assert (q.math_set == MathSet(s))
assert (isinstance(q.math_set, MathSet))
assert (p == q)
q.math_set.add(6)
# CAUTION: comparing p() and q() might yield False, due to ordering
f = p + q
assert (isinstance(f, PowerSet))
assert (f.math_set._set == {1, '3', 6})
assert (compare_lists(f.math_set._list, [[1, 2], {'a': 1}]))
return s
def powerset_test():
s = [[1, 2], "3", {"a": 1}, 1]
p = PowerSet(s)
s2 = ["3", {"a": 1}, [1, 2], 1]
q = PowerSet()
q.math_set = MathSet(s2)
assert p.math_set == MathSet(s)
assert q.math_set == MathSet(s)
assert isinstance(q.math_set, MathSet)
assert p == q
q.math_set.add(6)
# CAUTION: comparing p() and q() might yield False, due to ordering
f = p + q
assert isinstance(f, PowerSet)
assert f.math_set._set == {1, "3", 6}
assert compare_lists(f.math_set._list, [[1, 2], {"a": 1}])
return s
def __init__(self):
ap_labels = PowerSet()
node_label_types = [
{'name': 'ap',
'values': ap_labels,
'setter': ap_labels.math_set,
'default': set()}]
super(LabeledGameGraph, self).__init__(node_label_types)
self.atomic_propositions = self.ap
# dot formatting
self._state_dot_label_format = {
'ap': '',
'type?label': '',
'separator': '\n'}
self.dot_node_shape = {'normal': 'rectangle'}
def _construct_wfa(all_propositions, false_propositions):
# Construct WFA for invariant spec
# ! \wedge_{props \in false_propositions} \vee_{prop \in props} prop
fa = WFA()
fa.atomic_propositions.add_from(all_propositions)
fa.states.add_from({"q0"})
fa.states.initial.add("q0")
fa.states.accepting.add("q0")
transition_letters = set()
for propositions in false_propositions:
props_without_false = copy.deepcopy(fa.atomic_propositions)
for prop in propositions:
props_without_false.remove(prop)
transition_letters |= set(PowerSet(props_without_false))
for letter in transition_letters:
fa.transitions.add("q0", "q0", letter=letter)
return fa
ts.states.initial.add(baseState)
for transition in setOfTransitions:
ts.transitions.add(transition.prevState, transition.nextState, 1)
ts.atomic_propositions.add("VALID")
ts.atomic_propositions.add("SAT")
for s in setOfStates:
ts.states[s]["ap"] = set(s.labels)
# ts = synchronous_parallel([ts])
fa1 = WFA()
fa1.atomic_propositions.add_from(ts.atomic_propositions)
fa1.states.add_from({"q0"})
fa1.states.initial.add("q0")
fa1.states.accepting.add("q0")
ap_with_both = copy.deepcopy(fa1.atomic_propositions)
transition_letters = set(PowerSet(ap_with_both))
for letter in transition_letters:
fa1.transitions.add("q0", "q0", letter=letter)
spec = PrioritizedSpecification()
spec.add_rule(fa1, priority=1, level=0)
(cost, state_path, product_path, wpa) = solve_mvp(ts, "SAT", spec)
print("Optimal cost: {}".format(cost))
print("State path: {}".format(state_path))
print("Product path: {}".format(product_path))
#wpa.plot()
def __init__(self, env_actions=None, sys_actions=None):
"""Instantiate finite transition system.
@param env_actions: environment (uncontrolled) actions,
defined as C{edge_label_types} in L{LabeledDiGraph.__init__}
@param sys_actions: system (controlled) actions, defined as
C{edge_label_types} in L{LabeledDiGraph.__init__}
"""
self._owner = 'sys'
if env_actions is None:
env_actions = [
{'name': 'env_actions',
'values': MathSet(),
'setter': True}]
if sys_actions is None:
sys_actions = [
{'name': 'sys_actions',
'values': MathSet(),
'setter': True}]
# note: "sys_actions" used to be "actions"
# in closed systems (old FTS)
action_types = env_actions + sys_actions
edge_label_types = action_types
ap_labels = PowerSet()
node_label_types = [
{'name': 'ap',
'values': ap_labels,
'setter': ap_labels.math_set,
'default': set()}]
super(FiniteTransitionSystem, self).__init__(
node_label_types, edge_label_types)
# make them available also via an "actions" dicts
# name, codomain, *rest = x
actions = {x['name']: x['values'] for x in edge_label_types}
if 'actions' in actions:
msg = '"actions" cannot be used as an action type name,\n'
msg += 'because if an attribute for this action type'
msg += 'is requested,\n then it will conflict with '
msg += 'the dict storing all action types.'
raise ValueError(msg)
self.actions = actions
self.atomic_propositions = self.ap
self.aps = self.atomic_propositions # shortcut
# action constraint used in synth.synthesize
self.env_actions_must = 'xor'
self.sys_actions_must = 'xor'
# dot formatting
self._state_dot_label_format = {
'ap': '',
'type?label': '',
'separator': r'\\n'}
self._transition_dot_label_format = {
'sys_actions': 'sys', # todo: '' if no env
'env_actions': 'env',
'type?label': ':', # todo: '' if no env
'separator': r'\\n'}
self._transition_dot_mask = dict()
self.dot_node_shape = {'normal': 'box'} # todo: rectangle if no env
self.default_export_fname = 'fts'
def setUp(self):
self.p = PowerSet({1, 2, 3})
self.q_unhashable = PowerSet(MathSet([[1, 2], ["a", "b"]]))
self.singleton = PowerSet(set([1]))
self.empty = PowerSet()
def generate_trace(graph, override=False):
# check if synthesis results already exist for the input graph. if so, return stored value
if not override:
if graph.base_state in synthesis_dictionary.keys():
return synthesis_dictionary[graph.base_state]
ts = WKS()
ts.states.add_from(graph.states)
ts.states.initial.add(graph.base_state)
for transition in graph.transitions:
ts.transitions.add(transition[0], transition[2], {"cost": 1})
ts.atomic_propositions.add("VALID")
ts.atomic_propositions.add("WRONG_PORT")
ts.atomic_propositions.add("OVERFLOWED_PORT")
ts.atomic_propositions.add("FINISH")
for s in graph.states:
ts.states[s]["ap"] = set(s.labels)
fa0 = WFA()
fa0.atomic_propositions.add_from(ts.atomic_propositions)
fa0.states.add_from({"q0"})
fa0.states.initial.add("q0")
fa0.states.accepting.add("q0")
ap_without_valid = copy.deepcopy(fa0.atomic_propositions)
ap_without_valid.remove("VALID")
valid = {"VALID"}
for letter in PowerSet(ap_without_valid): # union of everything with valid
fa0.transitions.add("q0", "q0", letter=set(letter) | valid)
fa1 = WFA()
fa1.atomic_propositions.add_from(ts.atomic_propositions)
fa1.states.add_from({"q0"})
fa1.states.initial.add("q0")
fa1.states.accepting.add("q0")
ap_without_wrong_port = copy.deepcopy(fa1.atomic_propositions)
ap_without_wrong_port.remove("WRONG_PORT")
wrong_port = {"WRONG_PORT"}
for letter in PowerSet(ap_without_wrong_port):
fa1.transitions.add("q0", "q0", letter=letter)
fa2 = WFA()
fa2.atomic_propositions.add_from(ts.atomic_propositions)
fa2.states.add_from({"q0"})
fa2.states.initial.add("q0")
fa2.states.accepting.add("q0")
ap_without_port_overflow = copy.deepcopy(fa2.atomic_propositions)
ap_without_port_overflow.remove("OVERFLOWED_PORT")
for letter in PowerSet(ap_without_port_overflow):
fa2.transitions.add("q0", "q0", letter=letter)
spec = PrioritizedSpecification()
spec.add_rule(fa0, priority=1, level=0)
spec.add_rule(fa1, priority=1, level=1)
spec.add_rule(fa2, priority=2, level=1)
(cost, state_path, product_path, wpa) = solve_mvp(ts, "FINISH", spec)
synthesis_dictionary[graph.base_state] = (cost, state_path, product_path, wpa)
# print("Optimal cost: {}".format(cost))
# print("State path: {}".format(state_path))
# print("Product path: {}".format(product_path))
return (cost, state_path, product_path, wpa)
def tulip_tests(graph):
ts = WKS()
ts.states.add_from(graph.states)
ts.states.initial.add(graph.base_state)
for transition in graph.transitions:
ts.transitions.add(transition[0], transition[2], {"cost": 1})
ts.atomic_propositions.add("VALID")
ts.atomic_propositions.add("WRONG_PORT")
ts.atomic_propositions.add("OVERFLOWED_PORT")
ts.atomic_propositions.add("FINISH")
for s in graph.states:
ts.states[s]["ap"] = set(s.labels)
fa0 = WFA()
fa0.atomic_propositions.add_from(ts.atomic_propositions)
fa0.states.add_from({"q0"})
fa0.states.initial.add("q0")
fa0.states.accepting.add("q0")
ap_without_valid = copy.deepcopy(fa0.atomic_propositions)
ap_without_valid.remove("VALID")
valid = {"VALID"}
for letter in PowerSet(ap_without_valid): # union of everything with valid
fa0.transitions.add("q0", "q0", letter=set(letter) | valid)
fa1 = WFA()
fa1.atomic_propositions.add_from(ts.atomic_propositions)
fa1.states.add_from({"q0"})
fa1.states.initial.add("q0")
fa1.states.accepting.add("q0")
ap_without_wrong_port = copy.deepcopy(fa1.atomic_propositions)
ap_without_wrong_port.remove("WRONG_PORT")
wrong_port = {"WRONG_PORT"}
for letter in PowerSet(ap_without_wrong_port):
fa1.transitions.add("q0", "q0", letter=letter)
fa2 = WFA()
fa2.atomic_propositions.add_from(ts.atomic_propositions)
fa2.states.add_from({"q0"})
fa2.states.initial.add("q0")
fa2.states.accepting.add("q0")
ap_without_port_overflow = copy.deepcopy(fa2.atomic_propositions)
ap_without_port_overflow.remove("OVERFLOWED_PORT")
for letter in PowerSet(ap_without_port_overflow):
fa2.transitions.add("q0", "q0", letter=letter)
spec = PrioritizedSpecification()
spec.add_rule(fa0, priority=1, level=0)
spec.add_rule(fa1, priority=1, level=1)
spec.add_rule(fa2, priority=2, level=1)
(cost, state_path, product_path, wpa) = solve_mvp(ts, "FINISH", spec)
print("Optimal cost: {}".format(cost))
print("State path: {}".format(state_path))
print("Product path: {}".format(product_path))
