def test_count():
g = x_and_y()
assert g.count(4) == 1
g = x_or_y()
r = g.count(4)
assert r == 3, r
r = g.count(4, nvars=2)
assert r == 3, r
r = g.count(-4)
assert r == 1, r
r = g.count(-4, nvars=2)
assert r == 1, r
r = g.count(4, 3)
assert r == 6, r
r = g.count(-4, 3)
assert r == 2, r
with nt.assert_raises(Exception):
g.count()
r = g.count(4)
assert r == 3, r
g = _bdd.BDD()
g.add_var('x')
g.add_var('y')
u = g.add_expr('x /\ y ')
r = g.count(u)
assert r == 1, r
def consolidate_paths(automata, eliminate_goal_loop=False):
transitions = defaultdict(list)
final_trans = {}
for trans in automata['transitions']:
a, lbl = trans
b = automata['transitions'][trans]
if lbl == '':
transitions[(a, b)].append(lbl)
else:
if ',' in lbl:
if not eliminate_goal_loop:
final_trans[trans] = b
elif a != b:
final_trans[trans] = b
else:
transitions[(a, b)].append(f'({lbl})')
vocab = list(automata['alphabet'])
for a, b in transitions:
bdd = _BDD.BDD()
bdd.declare(*vocab)
formula = set(transitions[(a, b)])
if '' in formula:
formula.remove('')
if len(formula) >= 1:
formula = '|'.join(formula)
formula2 = bdd_to_min_formula(bdd, bdd.add_expr(formula.upper()))
else:
formula2 = ''
final_trans[(a, formula2)] = b
automata['transitions'] = final_trans
return automata
def _init_bdd(use_cudd):
if _bdd is None:
raise ImportError('Failed to import `dd.bdd`.\n'
'Install package `dd`.')
if not use_cudd:
return _bdd.BDD()
if cudd is None:
raise ImportError('Failed to import module `dd.cudd`.\n'
'Compile the Cython bindings of `dd` to CUDD.')
return cudd.BDD()
def solve_queens(n):
"""Return set of models for the `n`-queens problem.
@rtype: `int`, `BDD`
"""
vrs = [_var_str(i, j) for i in range(n) for j in range(n)]
bdd = _bdd.BDD()
bdd.declare(*vrs)
s = queens_formula(n)
u = bdd.add_expr(s)
return u, bdd
def solve_queens(n):
"""Return set of models for the `n`-queens problem.
@rtype: `int`, `BDD`
"""
v = [_var_str(i, j) for i in xrange(n) for j in xrange(n)]
d = {xij: level for level, xij in enumerate(v)}
bdd = _bdd.BDD(d)
s = queens_formula(n)
u = bdd.add_expr(s)
return u, bdd
def __init__(self):
# player 0 moves first (cox reverses this)
self.players = dict() # dict(str: int) maps: name -> turn
self.vars = dict()
# auto-populated
self.prime = dict()
self.unprime = dict()
self.turns = list()
# formulae
self.init = dict() # dict(key=list())
self.action = dict()
self.win = dict()
# aux
self.bdd = _bdd.BDD()
def _evaluate_result(result, memory):
"""Return integer, given a result and memory w/o variables.
@type result: `list`
@type memory: `list`
"""
bdd = _bdd.BDD({'x': 0})
n = len(memory) + 1
mem = ' '.join(memory)
bits = list()
for bit in result:
s = '$ {n} {mem} {bit}'.format(n=n, mem=mem, bit=bit)
u = bddizer.add_expr(s, bdd)
bits.append(u)
bits = [b == 1 for b in bits]
# print([int(b) for b in bits])
j = bv.twos_complement_to_int(bits)
return j
def __init__(self, levels=None):
manager = _bdd.BDD(levels)
self._bdd = manager
self.vars = manager.vars
def dfa_intersection_to_rm(
automata,
reduce=False,
set_reward=True,
final_state=False
): # from alberto and https://spot.lrde.epita.fr/ipynb/product.html
# TODO consolidar caminos equivalentes
result = {
'alphabet': set().union(*[x["alphabet"] for x in automata]),
'states': set(),
'initial_state': "",
'accepting_states': set(),
'transitions': dict(),
'reward': defaultdict(int)
}
sdict = {}
todo = []
new_state = get_new_state()
def dst(state_numbers):
state_numbers_tuple = tuple(state_numbers)
p = sdict.get(state_numbers_tuple)
if p is None:
p = next(new_state)
sdict[state_numbers_tuple] = p
todo.append((state_numbers_tuple, p))
return p
result["initial_state"] = dst([aut['initial_state'] for aut in automata])
#Create new alphabet in case some invalid characters are used
alpha_dict = {}
nvar = new_var()
for a in result['alphabet']:
alpha_dict[a] = next(nvar)
bdd = None
maxima = 0
while todo:
tuple_rc, osrc = todo.pop()
lists_of_transitions = [
automata[i]['out'][tuple_rc[i]] for i in range(len(automata))
]
for elements in itertools.product(*lists_of_transitions):
del bdd
bdd = _BDD.BDD()
#bdd.declare(*result["alphabet"])
bdd.declare(*alpha_dict.values())
cond = bdd.add_expr("TRUE")
for ste, edge_cond in elements:
edge_cond = edge_cond.upper()
edge_cond = ''.join([
alpha_dict[x] if x in alpha_dict else x
for x in re.split('(TRUE|FALSE|!|&|\(|\)|\|)', edge_cond)
])
ec = bdd.add_expr(edge_cond)
cond = bdd.apply('&', cond, ec)
if bdd.to_expr(cond) != "FALSE":
reward = sum([
automata[i]["reward"][elements[i][0]]
for i in range(len(elements))
if elements[i][0] in automata[i]['reward']
])
dest = dst([e[0] for e in elements])
# TODO: check rm reduce if we want full reduce or to every subgoal
#if reward > 0:
# result["accepting_states"].add(dest)
if reward > maxima:
result["accepting_states"] = set([dest])
maxima = reward
elif reward == maxima:
result["accepting_states"].add(dest)
result["states"].add(osrc)
result["states"].add(dest)
# result["reward"][dest] = reward // This is if you want the reward at the node instead of the edge
if not set_reward:
reward = 0
result["transitions"][(osrc, bdd_to_formula(bdd, cond))] = (
dest, reward
) # dest // This is if you want the reward at the node instead of the edge
if reduce:
full_transitions = deepcopy(result['transitions'])
for k in result['transitions']:
result['transitions'][k] = result['transitions'][k][0]
"""
if k[0] not in result['accepting_states']:
result['transitions'][k] = result['transitions'][k][0] # only the next state
elif result['transitions'][k][0] != k[0]:
result['transitions'][k] = result['transitions'][k][0] # only the next state
"""
result = DFA.dfa_co_reachable(result)
for k in result['transitions']:
result['transitions'][k] = full_transitions[
k] # return the state and reward
# rename with actual reward
rm = {
'alphabet': set(),
'states': set(),
'initial_state': "",
'accepting_states': set(),
'transitions': dict(),
}
rm["alphabet"] = alpha_dict.values() #result["alphabet"]
new_states = dict()
for k in result[
"states"]: # result["reward"]: // This is if you want the reward at the node instead of the edge
new_states[k] = f'''{k}''' # \n{"{"}{result["reward"][k]}{"}"}'''
rm["states"].add(new_states[k])
if result["initial_state"] not in new_states:
new_states[result[
"initial_state"]] = f"""{result["initial_state"]}\n{"{"}0{"}"}"""
rm["initial_state"] = new_states[result["initial_state"]]
if final_state:
rm['accepting_states'] = result['accepting_states']
beta_dict = {}
for v, k in alpha_dict.items():
beta_dict[k] = v
new_transitions = dict()
for ini in result["transitions"]:
if final_state and new_states[ini[0]] in result['accepting_states']:
continue
end, reward = result["transitions"][ini]
transition = ini[1]
if transition == "":
transition = "True"
#ini = (new_states[ini[0]], ini[1]) // This is if you want the reward at the node instead of the edge
ini = (new_states[ini[0]],
str((transition, reward) if reward > 0 else transition))
end = new_states[end]
reward = result["reward"][end]
new_transitions[ini] = end
rm["transitions"] = new_transitions
# ''.join([beta_dict[x] for x in re.split('\W', ini[1])])
rm = consolidate_paths(rm)
rm["alphabet"] = result["alphabet"]
transitions = {}
for s, k in rm['transitions']:
r = rm['transitions'][(s, k)]
if len(k) == 0:
k = k
elif k[0] + k[-1] == '()':
t, v = eval(k)
if len(t) > 0:
t = ''.join([
f'{beta_dict[x]}' if x in beta_dict else x
for x in re.split('(TRUE|FALSE|!|&|\(|\)|\|)', t)
])
k = (t, v)
else:
k = ''.join([
f'{beta_dict[x]}' if x in beta_dict else x
for x in re.split('(TRUE|FALSE|!|&|\(|\)|\|)', k)
])
transitions[(s, str(k))] = r
rm['transitions'] = transitions
return rm
def __init__(self, ordering=None):
bdd = _bdd.BDD(ordering)
self.vars = bdd.vars
self._bdd = bdd