def findAllWays(f):
v = bdd.expr("0")
v = bdd.expr2bdd(v)
for i in f.satisfy_all():
s = bdd.expr("1")
s = bdd.expr2bdd(s)
for a in i.items():
if (a[1] == 1):
s = s & a[0]
else:
s = s & ~a[0]
v = v | s
return v
def venn_from_str(venn_str: str, value_parser: Callable[[str], T]) -> Set[T]:
# The values have to be surrounded by a single space.
BOOL_REGEX = '[\(\)\|\&\~]+'
pyeda_str = ''
pyeda_sym_to_val = OrderedDict() # type: MutableMapping[str, T]
venn_sym_to_pyeda_sym = OrderedDict() # type: MutableMapping[str, str]
current_sym = 0
parts = venn_str.split()
for part in parts:
match = re.match(BOOL_REGEX, part)
if match and match.string == part:
pyeda_str += part
else:
if part in venn_sym_to_pyeda_sym.keys():
pyeda_str += venn_sym_to_pyeda_sym[part]
else:
pyeda_sym = SYMS[current_sym]
current_sym += 1
venn_sym_to_pyeda_sym[part] = pyeda_sym
pyeda_sym_to_val[pyeda_sym] = value_parser(part)
pyeda_str += pyeda_sym
return venn_from_pyeda(expr(pyeda_str), pyeda_sym_to_val)
def _getTempsDelexpression(listedMatrix):
"""
initially check if the voxel is a curve end point
if it is do not delete it.. Else proceed to compare
voxel with different possible templates
"""
"""
each template is implemented as a boolean expression of symbols
where each symbol represents each one of the 26 neighbors
"""
str1 = ''.join(str(e) for e in listedMatrix)
a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z = map(
exprvar, str1)
direction1 = (~(a) & ~(b) & ~(c) & ~(j) & ~(k) & ~(l) & ~(r) & ~(s) & ~(t) & p & (d | e | f | m | n | u | v | w | g | h | i | o | q | x | y | z)) | \
(~(a) & ~(b) & ~(c) & ~(d) & ~(e) & ~(f) & ~(g) & ~(h) & ~(i) & v & (d | e | f | m | n | u | v | w | g | h | i | o | q | x | y | z)) | \
(~(a) & ~(b) & ~(c) & ~(j) & ~(k) & ~(l) & ~(r) & ~(s) & ~(t) & ~(d) & ~(e) & ~(f) & ~(g) & ~(g) & ~(h) & ~(i) & y & (m | n | u | w | o | q | x | z)) | \
(~(a) & ~(b) & ~(c) & ~(k) & ~(e) & ~(d & j) & ~ (l & f) & p & v) | \
(~(a) & ~(b) & ~(k) & ~(e) & c & v & p & ~(j & d) & ((l & ~(f)) | (~(l) & f))) | \
(a & v & p & ~(b) & ~(c) & ~(k) & ~(e) & ~(l & f) & ((j & ~(d)) | (~(j) & d))) | \
(~(a) & ~(b) & ~(k) & ~(e) & n & v & p & ~(j & d)) | \
(~(b) & ~(c) & ~(k) & ~(e) & m & v & p & ~(l & f)) | \
(~(b) & ~(k) & ~(e) & a & n & v & p & ((j & ~(d)) | (~(j) & d))) | \
(~(b) & ~(k) & ~(e) & c & m & v & p & ((l & ~(f)) | (~(l) & f))) | \
(~(a) & ~(b) & ~(c) & ~(j) & ~(k) & ~(l) & ~(r) & ~(s) & ~(t) & ~(d) & ~(e) & ~(g) & ~(h) & q & y) | \
(~(a) & ~(b) & ~(c) & ~(j) & ~(k) & ~(l) & ~(r) & ~(s) & ~(t) & ~(e) & ~(f) & ~(h) & ~(i) & o & y) | \
(~(a) & ~(b) & ~(c) & ~(j) & ~(k) & ~(r) & ~(s) & ~(d) & ~(e) & ~(f) & ~(g) & ~(h) & ~(i) & w & y) | \
(~(a) & ~(b) & ~(c) & ~(d) & ~(e) & ~(f) & ~(g) & ~(h) & ~(i) & ~(k) & ~(l) & ~(s) & ~(t) & u & y)
return expr(direction1, simplify=True)
def text2bddExpr(text):
formula = expr2bdd(expr(text))
print(expr(text))
gv = Source(formula.to_dot())
file_path = "selfGeneratedDot.dot"
gv.render(filename=file_path, format='png', view=False)
return file_path
# text2bddExpr("Or(a,b,c)")
# get_dot_from_json("delete_this.json", "delete_this.dot")
#text2bddExpr("a|b&c")
# render("dot", "png", "delete_this.dot")
# render("delete_this.dot", format='png')
def connect_to_edges(ff):
jF = ""
index = 0
j = 1
for temp in ff:
jF += f"({temp}) | "
jF = pyeda.expr(jF[:-3])
return jF
def variables(rule):
"""
given a string formatted as a | b
return a set of the variables as strings
"""
if rule in ('True', 'False'):
return set()
else:
return set(str(x) for x in expr(rule, simplify=False).support)
def joinEdgeList(edgeList):
jointForm = ""
# Add the ORs
for edgeForm in edgeList:
jointForm += f"({edgeForm}) | "
jointForm = pyeda.expr(jointForm[:-3])
return jointForm
def perform_bin_expr_min(base_tokens: list, wildcard='*'):
""" Perform binary expression minimization for a list of base tokens
:param list base_tokens: list of base tokens that have same length.
Each base token is a list of '0' or '1'.
:param wildcard: the element to denote "do not care" character
:returns: list of minimized tokens of '0', '1' or 'wildcard'
"""
if not base_tokens:
return []
dim = len(base_tokens[0])
X = exprvars('x', dim)
f = expr(0) # start of an OR
for baseToken in base_tokens:
prod = expr(1) # start of an AND
for i in range(dim):
if baseToken[i] == 1:
prod = prod & X[i]
else:
prod = prod & ~X[i]
f = f | prod
# minimize
fm, = espresso_exprs(f.to_dnf())
min_tokens = []
for s in fm.cover:
min_token = []
for i in range(dim):
if X[i] in s:
min_token.append(1)
elif ~X[i] in s:
min_token.append(0)
else:
min_token.append(wildcard)
min_tokens.append(min_token)
return min_tokens
def generate_bdd(comparison: list, expressions: list) -> list:
'''
Method that converts given expressions into BDD for a given R.
Parameter list: comparison list and expression list.
returns: BDD as list for a given R.
'''
R = comparison
for expr in expressions:
R = R or expr2bdd(expr(expr))
return R
def check_input(self):
try:
self.propositional_formula = p.expr(self.propositional_str)
except NameError:
raise NameError
except TypeError:
raise TypeError
except Exception:
raise Exception
def eval_boolean_func(self, vars: Dict[T, bool]) -> bool:
val_to_sym = self._make_val_to_sym_dict()
try:
evaluated = self._to_pyeda_expr(val_to_sym).restrict({expr(sym): vars[val] for val, sym in val_to_sym.items()})
except KeyError as e:
raise AssertionError('eval_boolean_func missing variable {}'.format(e.args[0]))
if evaluated.is_one():
return True
elif evaluated.is_zero():
return False
else:
raise AssertionError
def joinEdgeFormulaList(edgeFormulaList):
jointFormula = ""
# Add the OR between each formula
for edgeFormula in edgeFormulaList:
jointFormula += f"({edgeFormula}) | "
# Convert the formula string to a pyeda expression
# chopping off the extra OR for formatting
jointFormula = pyeda.expr(jointFormula[:-3])
return jointFormula
def minimize_rule(rule):
"""
Given a rule in string form 'a | b & c',
return (as strings)
the espresso minimized form of the rule
and the support (set of variables in the minimized rule)
Why don't we just return the minimized rule? There can be problems
converting the minimized rule back to an expression due to recursion depth.
"""
f1 = expr(rule)
if f1.is_one() or f1.is_zero():
reduced_rule = str(bool(f1))
return reduced_rule, set()
else:
f1_min, = espresso_exprs(f1.to_dnf())
return str(f1_min), set(str(x) for x in f1_min.support)
def connectivity(g, n, d):
kini = exprzeros(n, n)
kend = exprones(n, n)
c = []
for i in range(n):
kini[i, i] = expr(1)
if d == 1:
for i in range(n):
c += kupdate(g, n, 0, i, kini, kend)
else:
km = exprvars('km', d - 1, n, n)
for i in range(n):
c += kupdate(g, n, 0, i, kini, km[0])
for k in range(1, d - 1):
for i in range(n):
c += kupdate(g, n, k, i, km[k - 1], km[k])
for i in range(n):
c += kupdate(g, n, d - 1, i, km[d - 2], kend)
return c
def read_cuts(filename):
"""!
Function reads dictionary of pyeda cuts from file
"""
print_info("Reading cuts from file")
cuts_str = read_dict(filename)
cuts = {}
counter = 0
for node in cuts_str:
cuts[node] = []
for cut in cuts_str[node]:
cuts[node].append(expr(cut))
counter = counter +1
draw_progress_bar(counter / len(cuts_str))
print()
return cuts
def categorize_rule(rule):
"""
given a string formatted as a | b
run checks to make sure it is ok to try to minimize it
sort it into a category
"""
try:
e = expr(rule, simplify=True)
esup = e.support
except:
if rule == '|' or rule == '&' or rule == '~':
return 'And/Or/Not'
elif 'at least' in rule.lower() or 'at most' in rule.lower(
) or 'exactly' in rule.lower():
return 'At least/At most/Exactly'
else:
return 'Invalid statement'
if len(esup) > 30:
return 'Big statement'
return 'Small statement'
def EquivalentCheckFromFile(path1, path2):
answ1 = exe.Execution(path1)
answ2 = exe.Execution(path2)
prs = parser.Parser(path1)
for name in prs.varNames("output"):
r1 = bdd.expr2bdd(answ1[name][0])
r3 = bdd.expr2bdd(answ2[name][0])
f1 = findAllWays(~r1) & findAllWays(r3)
if (~f1.is_zero()):
return f1
r2 = bdd.expr2bdd(answ1[name][1])
r4 = bdd.expr2bdd(answ2[name][1])
f2 = findAllWays(~r1) & findAllWays(r2) & findAllWays(
~r3) & findAllWays(~r4)
if (~f2.is_zero()):
return f2
f3 = findAllWays(~r1) & findAllWays(~r2) & findAllWays(
~r3) & findAllWays(r4)
if (~f3.is_zero()):
return f3
f = bdd.expr("0")
return f
def read_circuit_functions(filename):
"""!
Function reads circuit functions from file to dictionary
"""
print_info("Reading circuit functions from file")
circuitFunctions_str = read_dict(filename)
circuitFunctions = {}
for circuit in circuitFunctions_str:
circuitFunctions[circuit] = {}
for func in circuitFunctions_str[circuit].keys():
circuitFunctions[circuit][func] = {}
if func.startswith("INPUTS"):
circuitFunctions[circuit][func] = literal_eval(circuitFunctions_str[circuit][func])
else:
circuitFunctions[circuit][func] = expr(circuitFunctions_str[circuit][func])
#~ print(str(datetime.now().replace(microsecond=0)) + " " + design_name +" -Finished reading circuit functions from file")
return circuitFunctions
def _to_pyeda_expr(self, val_to_sym: MutableMapping[Any, str]) -> Expression:
return expr(val_to_sym[self.value])
def is_subset_of(self, other: 'Set[T]') -> bool:
val_to_sym = self._make_val_to_sym_dict()
val_to_sym = other._make_val_to_sym_dict(val_to_sym)
return Implies(self._to_pyeda_expr(val_to_sym), other._to_pyeda_expr(val_to_sym)).equivalent(expr(1))
def boolZero():
f = bdd.expr("0")
f = bdd.expr2bdd(f)
g = bdd.expr("0")
g = bdd.expr2bdd(g)
return (f, g)
def boolX():
f = bdd.expr("1")
f = bdd.expr2bdd(f)
g = bdd.expr("0")
g = bdd.expr2bdd(g)
return (f, g)
import sys
from pyeda.inter import expr, exprvars, Or, Implies, Equal
from network import vsort, Network, to_bit
from sorting import forward_depth
TRUE = expr(True)
FALSE = expr(False)
class Halver(Network):
def is_halver(self, n, epsilon, log=False):
maxeps = 0
for x in range(1<<n):
y = self.output(x)
if get_epsilon(n, y) > epsilon:
maxeps = get_epsilon(n, y)
if log:
print(to_bit(x, n), '->', to_bit(y, n), '(eps={})'.format(maxeps), 'Fails', file=sys.stderr)
return False
elif get_epsilon(n, y) > maxeps:
maxeps = get_epsilon(n, y)
if log:
print(to_bit(x, n), '->', to_bit(y, n), '(eps={})'.format(maxeps), file=sys.stderr)
return True
def to_ehalver(point, g, n, d):
assert g.ndim == 2
m = n//2
if point is not None:
if type(point) is list:
pairs = [[(i, j+m) for i in range(m) for j in range(m) if g[k+i, j] in point] for k in range(0, d*m, m)]
bdds_together = join_disjunct(bdds)
print("bdds_together: long string bdd for entire equation")
pprint(bdds_together)
# step 4'
printHeader("Step 4'")
x_names = names[0:5]
p_bdds = join_disjunct(
map(lambda x: transformEdge(x, x_names), map(lambda x: getBin(x, 5),
primes)))
p = expr2bdd(expr(p_bdds))
y_names = names[5:-1]
e_bdds = join_disjunct(
map(lambda y: transformEdge(y, y_names), map(lambda y: getBin(y, 5),
evens)))
e = expr2bdd(expr(e_bdds))
print("p_bdds: like bdds_together")
pprint(p_bdds)
print("e_bdds: like bdds_together")
pprint(e_bdds)
# step 5
printHeader("Step 5")
def Card(a, p, prefix=''):
k = 1 << (p - 1).bit_length()
n = ((len(a) - 1) // k + 1) * k
a = list(a) + [expr(False)] * (n - len(a))
return Card2(a, k, prefix)
# only vote for punishers
poss_beh_vrules = [
[p],
]
# NOTE for now the only pun_vrule is punishing self
# create all possible personalities
# ----
poss_pers = list()
pers_id = 0 # just to be handy
for beh in poss_behs:
# if a punisher ...
if And(beh, ~p) == expr(
False): # if the product beh contains p, then And(beh, ~p) = False
for prules in poss_prules:
# ... and a voter
if And(beh, ~v) == expr(
False
): # if the product beh contains p, then And(beh, ~p) = False
for beh_vrules in poss_beh_vrules:
poss_pers.append({
'beh': beh,
'prules': prules,
'beh_vrules': beh_vrules,
'pun_vrules': [beh],
def _getTempsDelexpression(listedMatrix):
"""
initially check if the voxel is a curve end point
if it is do not delete it.. Else proceed to compare
voxel with different possible templates
"""
"""
each template is implemented as a boolean expression of symbols
where each symbol represents each one of the 26 neighbors
"""
str1 = "".join(str(e) for e in listedMatrix)
a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z = map(exprvar, str1)
direction1 = (
(
~(a)
& ~(b)
& ~(c)
& ~(j)
& ~(k)
& ~(l)
& ~(r)
& ~(s)
& ~(t)
& p
& (d | e | f | m | n | u | v | w | g | h | i | o | q | x | y | z)
)
| (
~(a)
& ~(b)
& ~(c)
& ~(d)
& ~(e)
& ~(f)
& ~(g)
& ~(h)
& ~(i)
& v
& (d | e | f | m | n | u | v | w | g | h | i | o | q | x | y | z)
)
| (
~(a)
& ~(b)
& ~(c)
& ~(j)
& ~(k)
& ~(l)
& ~(r)
& ~(s)
& ~(t)
& ~(d)
& ~(e)
& ~(f)
& ~(g)
& ~(g)
& ~(h)
& ~(i)
& y
& (m | n | u | w | o | q | x | z)
)
| (~(a) & ~(b) & ~(c) & ~(k) & ~(e) & ~(d & j) & ~(l & f) & p & v)
| (~(a) & ~(b) & ~(k) & ~(e) & c & v & p & ~(j & d) & ((l & ~(f)) | (~(l) & f)))
| (a & v & p & ~(b) & ~(c) & ~(k) & ~(e) & ~(l & f) & ((j & ~(d)) | (~(j) & d)))
| (~(a) & ~(b) & ~(k) & ~(e) & n & v & p & ~(j & d))
| (~(b) & ~(c) & ~(k) & ~(e) & m & v & p & ~(l & f))
| (~(b) & ~(k) & ~(e) & a & n & v & p & ((j & ~(d)) | (~(j) & d)))
| (~(b) & ~(k) & ~(e) & c & m & v & p & ((l & ~(f)) | (~(l) & f)))
| (~(a) & ~(b) & ~(c) & ~(j) & ~(k) & ~(l) & ~(r) & ~(s) & ~(t) & ~(d) & ~(e) & ~(g) & ~(h) & q & y)
| (~(a) & ~(b) & ~(c) & ~(j) & ~(k) & ~(l) & ~(r) & ~(s) & ~(t) & ~(e) & ~(f) & ~(h) & ~(i) & o & y)
| (~(a) & ~(b) & ~(c) & ~(j) & ~(k) & ~(r) & ~(s) & ~(d) & ~(e) & ~(f) & ~(g) & ~(h) & ~(i) & w & y)
| (~(a) & ~(b) & ~(c) & ~(d) & ~(e) & ~(f) & ~(g) & ~(h) & ~(i) & ~(k) & ~(l) & ~(s) & ~(t) & u & y)
)
return expr(direction1, simplify=True)
def simplify(expression):
simplified_expr, = eda.espresso_exprs(eda.expr(expression).to_dnf())
return EspressoSimplifier.convert(simplified_expr)
#!/usr/bin/env python3
from pyeda.inter import expr, expr2bdd, bddvar
# type
# expr.Variable
# expr.OrOp
#
# bdd.BDDVariable
# bdd.BinaryDecisionDiagram
#
# expr() => expr.*
# expr2bdd() => from expr to bdd
# bddvar() => bdd.BDDVariable
#
# both expr and bdd can use ~|&^ operator
# f = expr('a & b | b & c | c & a')
f = expr('a1_1 & a2_1 | a2_1 & a2_2 | a2_2 & a1_1')
g = f | expr('d')
# type(f) => expr
# type(g) => expr
f2 = expr2bdd(f)
# type(f2) = bdd
print(f2.satisfy_one())
print(f2.satisfy_all()) # generator
print(list(f2.satisfy_all()))
print(f2.satisfy_count())
print(f2.to_dot())
