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())