def construct_buchi_graph(self): """ parse the output of the program ltl2ba and build the buchi automaton """ # directory of the program ltl2ba dirname = os.path.dirname(__file__) # output of the program ltl2ba output = subprocess.check_output(dirname + "/./ltl2ba -f \"" + self.formula + "\"", shell=True).decode("utf-8") # find all states/nodes in the buchi automaton state_re = re.compile(r'\n(\w+):\n\t') state_group = re.findall(state_re, output) # find initial and accepting states init = [s for s in state_group if 'init' in s] # treat the node accept_init as init node accept = [s for s in state_group if 'accept' in s] # finish the inilization of the graph of the buchi automaton self.buchi_graph.graph['init'] = init self.buchi_graph.graph['accept'] = accept # for each state/node, find it transition relations for state in state_group: # add node self.buchi_graph.add_node(state, label='', formula='') # loop over all transitions starting from current state state_if_fi = re.findall(state + r':\n\tif(.*?)fi', output, re.DOTALL) if state_if_fi: relation_group = re.findall(r':: (\(.*?\)) -> goto (\w+)\n\t', state_if_fi[0]) for symbol, next_state in relation_group: symbol = symbol.replace('||', '|').replace('&&', '&') edge_label = self.merge_check_feasible(symbol) if edge_label: # update node, no edges for selfloop if state == next_state: self.buchi_graph.nodes[state]['label'] = edge_label self.buchi_graph.nodes[state]['formula'] = to_dnf( symbol) # if 'accept' in state: # print(edge_label) continue # add edge self.buchi_graph.add_edge(state, next_state, label=edge_label, formula=to_dnf(symbol)) else: state_skip = re.findall(state + r':\n\tskip\n', output, re.DOTALL) if state_skip: self.buchi_graph.nodes[state]['label'] = 'skip' self.buchi_graph.nodes[state]['formula'] = 'skip' self.delete_node_no_selfloop_except_init_accept()
def hoftask(init, buchi_graph, regions): h_task = DiGraph(type='subtask') try: label = to_dnf( buchi_graph.edges[(buchi_graph.graph['init'][0], buchi_graph.graph['init'][0])]['label'], True) except KeyError: # no self loop label = to_dnf('0') init_node = State((init, buchi_graph.graph['init'][0]), label) h_task.add_node(init_node) open_set = list() open_set.append(init_node) explore_set = list() while open_set: curr = open_set.pop(0) # assume co-safe # if curr.q in buchi_graph.graph['accept']: # continue # print(curr) for q_b in buchi_graph.succ[curr.q]: try: label = to_dnf(buchi_graph.edges[(q_b, q_b)]['label'], True) except KeyError: # no self loop label = to_dnf('0') if q_b != curr.q: # and q_b not in buchi_graph.graph['accept']: # region corresponding to the label/word edge_label = (buchi_graph.edges[(curr.q, q_b)]['label']) if edge_label == '(1)': x_set = [curr.x] else: x_set = target(to_dnf(edge_label), regions) if x_set: for x in x_set: cand = State((x, q_b), label) # print(cand) if cand not in open_set and cand not in explore_set: open_set.append(cand) # check the match with each subtask in h_task if not match(h_task, curr, cand): # print(cand) h_task.add_node(cand) h_task.add_edge(curr, cand) # continue # roots for accepting states # if q_b in buchi_graph.graph['accept']: # h_task.add_edge(curr, cand) explore_set.append(curr) # for x in h_task.nodes: # print(x) return h_task
def parse_definition(definitions): """Convert a definitions set to its disjunctive normal form Keyword arguments: definition -- str, indicating AND and OR relationship between gene annotations (e.g. (A,B) C -> (A OR B) AND C). """ symbol_dict = get_symbol_dict(definitions) expr_text = definitions.replace(" ", " & ").replace(",", " | ").replace('+', ' & ') if expr_text.endswith('& ') or expr_text.endswith('| '): expr_text = expr_text[:-3] print(expr_text) try: expr = parse_expr(expr_text, local_dict=symbol_dict) except SyntaxError: print(definitions) print(expr_text) return dnf = to_dnf(expr) combinations = [ d.strip("() ").replace(" ", "") for d in str(dnf).split("|") ] combinations = [x.split("&") for x in combinations] return combinations
def inclusion(subtask_lib, subtask_new, tree, end2path): """ whether subtask_lib is included in subtask_new :param subtask_lib: :param subtask_new: :return: """ # trick # no need to build subtree for those who doesn't have self-loop and edge label != 1 []<> ( <>) if subtask_new[1].label == to_dnf( '0') and subtask_new[0].x != subtask_new[1].x: return 'zero' condition = not satisfiable( And(subtask_lib[1].label, Not(subtask_new[1].label))) if subtask_lib[0].x == subtask_new[0].x and subtask_lib[ 1].x == subtask_new[1].x: condition = condition or good_execution( end2path[(subtask_lib[0], subtask_lib[1])], subtask_new[1].label, tree) if condition: return 'forward' elif subtask_lib[0].x == subtask_new[1].x and subtask_lib[ 1].x == subtask_new[0].x: condition = condition or good_execution( end2path[(subtask_lib[0], subtask_lib[1])], subtask_new[1].label, tree) if condition: return 'backward' return ''
def pred(self, process = None): if process != None: return self._process_to_pred[process].pred() else: conjs = [self._process_to_pred[p].pred() for p in self._process_set] conj = And(*conjs) return to_dnf(conj)
def simplify_iconditions(iconditions, ignore_ne_isets=set()): ne_symbols = get_iconditions_ne_isets_logic_symbols( iconditions, ignore_ne_isets) dnf = convert_iconditions_2_disjunctive_formula(iconditions, ne_symbols) simplified_dnf = simplify(dnf) sim_dnf = to_dnf(dnf) return simplified_dnf, sim_dnf
def rank_Cdnf(self, Query, d_index): Q_t = self.get_terms(Query) Q = str(to_dnf(Query, simplify=True)) Q = Q.split("|") product = 1 for cc in Q: product *= self.rank_cc(cc, Q_t, d_index) return 1 - product
def select_group(self, formulas): selected = min(self.select_max_contains(formulas), key=lambda block: sum(len(to_dnf(formula).args) for formula in block)) print "selected" for j in selected: print j print '\n' return selected
def bool_symexpand(expr_string): from sympy.parsing.sympy_parser import parse_expr from sympy.logic.boolalg import to_dnf parsed_expr = parse_expr(expr_string, evaluate=False) new_locals = { sym.name: sympy.Symbol(sym.name) for sym in parsed_expr.atoms(sympy.Symbol) } return to_dnf(eval(expr_string, {}, new_locals), simplify=True)
def select_group(self, formulas): selected = min( self.select_max_contains(formulas), key=lambda block: sum(len(to_dnf(formula).args) for formula in block) ) print "selected" for j in selected: print j print "\n" return selected
def isp_simplify(file, ignore_isets=set()): formula = get_dnf_from_iconditions(file, ignore_isets) print(formula) simplified = simplify(formula) print("simplified: ", simplified) # print(to_dnf(left, simplify=True)) # msg.send_message(str(simplified)) print("dnf ", to_dnf(simplified)) return formula
def test_to_dnf(): assert to_dnf(~(B | C)) == And(Not(B), Not(C)) assert to_dnf(A & (B | C)) == Or(And(A, B), And(A, C)) assert to_dnf(A >> B) == (~A) | B assert to_dnf(A >> (B & C)) == (~A) | (B & C) assert to_dnf(A | B) == A | B assert to_dnf(Equivalent(A, B), True) == \ Or(And(A, B), And(Not(A), Not(B))) assert to_dnf(Equivalent(A, B & C), True) == \ Or(And(A, B, C), And(Not(A), Not(B)), And(Not(A), Not(C))) assert to_dnf(A + 1) == A + 1
def hoftask_no_simplified(init, buchi_graph, regions): try: label = to_dnf(buchi_graph.edges[(buchi_graph.graph['init'][0], buchi_graph.graph['init'][0])]['label'], True) except KeyError: # no self loop label = to_dnf('0') init_node = State((init, buchi_graph.graph['init'][0]), label) h_task = DiGraph(type='subtask', init=init_node) h_task.add_node(init_node) open_set = list() open_set.append(init_node) explore_set = list() while open_set: curr = open_set.pop(0) for q_b in buchi_graph.succ[curr.q]: try: label = to_dnf(buchi_graph.edges[(q_b, q_b)]['label'], True) except KeyError: # no self loop label = to_dnf('0') if q_b != curr.q: # region corresponding to the label/word edge_label = (buchi_graph.edges[(curr.q, q_b)]['label']) if edge_label == '(1)': x_set = [curr.x] else: x_set = target(to_dnf(edge_label), regions) if x_set: for x in x_set: cand = State((x, q_b), label) # whether cand is already in the h_task # cand = find_node(cand, h_task) h_task.add_edge(curr, cand) if cand not in open_set and cand not in explore_set: open_set.append(cand) explore_set.append(curr) return h_task
def convert_to_dnf(frml): # frml = to_dnf(frml, force=True).replace(" ","") frml = frml.replace("^", "~") sub_frml = get_sub_formulas(frml, P="P", add_prefix="Q") for single_sub_frml_index in range(len(sub_frml)): sub_frml[single_sub_frml_index] = remove_iff_single_frml( sub_frml[single_sub_frml_index][1:-1]) print(sub_frml[single_sub_frml_index]) sub_frml[single_sub_frml_index] = str( to_dnf(sub_frml[single_sub_frml_index], force=True)).replace(" ", "") for i in range(len(sub_frml)): current_index = sub_frml[i].find("P", 0) while current_index != -1: end_index = sub_frml[i].find("Q", current_index + 1) to_switch_index = int(sub_frml[i][current_index + 1:end_index]) - 1 sub_frml[i] = sub_frml[i].replace( "P" + str(to_switch_index + 1) + "Q", sub_frml[to_switch_index]) current_index = sub_frml[i].find("P", current_index + 1) return simplify_logic(str(to_dnf(sub_frml[-1], force=True)).replace(" ", ""), force=True)
def stringToDNF(ps): # Replace ands and ors so that sympify parses correctly ps = ps.replace("and", "&") ps = ps.replace("or", "|") # Need to remove dashes and add a letter before each course number while "-" in ps: i = ps.find("-") ps = ps[:(i-2)] + "c" + ps[(i-2):i] + ps[(i+1):] try: psSympified = sympify(ps) except SympifyError: return "" return str(to_dnf(psSympified))
def _create_symbolic_representation(self): """Creates a symbolic representation of the query to enable, among other things, manipulation with sympy so we can get to disjunctive normal form (DNF). """ # Find all the expressions and replace them with symbols. self.symbol_to_expression_map = {} symbolified_string = self.filter_string for regex in [SAMPLE_SCOPE_REGEX, EXPRESSION_REGEX, SET_REGEX, GENE_REGEX]: symbolified_string = self._symbolify_string_for_regex( symbolified_string, regex) symbolified_string = re.sub('AND|and', '&', symbolified_string) symbolified_string = re.sub('OR|or', '|', symbolified_string) self.sympy_representation = boolalg.to_dnf(symbolified_string)
def target(exp, regions): """ find the target location :param label: word :return: target location/region """ target = [] if exp != to_dnf('1'): # a set of target points for dnf in exp.args or [exp]: truth_table = satisfiable(dnf, algorithm="dpll") # find the target point with true value for key, value in truth_table.items(): if value: des = key.name.split('_')[0] target.append(regions[des]) return target
def _create_symbolic_representation(self): """Creates a symbolic representation of the query to enable, among other things, manipulation with sympy so we can get to disjunctive normal form (DNF). """ # Find all the expressions and replace them with symbols. self.symbol_to_expression_map = {} symbolified_string = self.filter_string for regex in [ SAMPLE_SCOPE_REGEX, EXPRESSION_REGEX, SET_REGEX, GENE_REGEX ]: symbolified_string = self._symbolify_string_for_regex( symbolified_string, regex) symbolified_string = re.sub('AND|and', '&', symbolified_string) symbolified_string = re.sub('OR|or', '|', symbolified_string) self.sympy_representation = boolalg.to_dnf(symbolified_string)
def to_dnf(association): # A and B and (C or D) or E association = association.replace(' AND ',' & ').replace(' OR ',' | ').replace(' and ',' & ').replace(' or ',' | ') # -> A & B & (C | D) | E association = str(boolalg.to_dnf(association)) # -> Or(And(A, B, C), And(A, B, D), E) for and_old in re.findall(r'And\([^)]+\)',association): and_new = and_old and_new = and_new.replace('And(','(') and_new = and_new.replace(', ',' and ') association = association.replace(and_old, and_new) # -> Or((A and B and C), (A and B and D), E) association = association.replace(', ', ' or ') if association[:3] == 'Or(': association = association[3:-1] # .. -> (A and B) or (A and C) or D if association == 'False': association = '' return association
def get_truth_assignment(self, symbol): """ get one set of truth assignment that makes the symbol true :param symbol: logical expression which controls the transition :return: a set of truth assignment enables the symbol """ # empty symbol if symbol == '(1)': return '1' # non-empty symbol else: exp = symbol.replace('||', '|').replace('&&', '&').replace('!', '~') exp_dnf = to_dnf(exp).__str__() # loop over each clause for clause in exp_dnf.split(' | '): truth_table = dict() clause = clause.strip('(').strip(')') literals = clause.split(' & ') # loop over each literal for literal in literals: if '~' not in literal: truth_table[literal] = True else: truth_table[literal[1:]] = False # whether exist a literal with positive and negative version if len(literals) != len(truth_table): continue else: # exist a robot with two positive literals true_key = [ truth.split('_')[1] for truth in truth_table.keys() if truth_table[truth] ] if len(true_key) != len(set(true_key)): continue else: # print(clause, truth_table) return truth_table return dict()
def to_dnf(association): # A and B and (C or D) or E association = association.replace(' AND ', ' & ').replace( ' OR ', ' | ').replace(' and ', ' & ').replace(' or ', ' | ') # -> A & B & (C | D) | E association = str(boolalg.to_dnf(association)) # -> Or(And(A, B, C), And(A, B, D), E) for and_old in re.findall(r'And\([^)]+\)', association): and_new = and_old and_new = and_new.replace('And(', '(') and_new = and_new.replace(', ', ' and ') association = association.replace(and_old, and_new) # -> Or((A and B and C), (A and B and D), E) association = association.replace(', ', ' or ') if association[:3] == 'Or(': association = association[3:-1] # .. -> (A and B) or (A and C) or D if association == 'False': association = '' return association
def __init__(self, formulae): def parse_cnfdnf(f, t): if t == "cnf": t = (And, Or) elif t == "dnf": t = (Or, And) if not isinstance(f, t[0]): if isinstance(f, Symbol): return [(f, )] else: return [tuple(f.args)] ret = [] for a in f.args: if not isinstance(a, t[1]): ret.append((a, )) else: ret.append(tuple(a.args)) return ret self.formulae = formulae self.cnf = to_cnf(formulae, simplify=False) self.cnf_parsed = parse_cnfdnf(self.cnf, "cnf") self.dnf = to_dnf(formulae, simplify=False) self.dnf_parsed = parse_cnfdnf(self.dnf, "dnf")
def rule_manipulation(bw_rules, percentages, simulations): n = len(bw_rules) rulefilelist = [''] * simulations for sim in range(simulations): bw_rulelist = copy.deepcopy(bw_rules) transition_states = [] states_count = [] rule_length = [0] * n for i in range(n): rule_length[i] = len(bw_rulelist[i]) new_rule_length = [ math.ceil(a * b) for a, b in zip(rule_length, percentages) ] # keep track how many times the transition state is still left # it must not be totally eliminated from the system, otherwise # it would create an additional steady state for k in range(n): for i in bw_rulelist[k]: #print(i) if i not in transition_states: transition_states.append(i) states_count.append(1) else: states_count[transition_states.index( i)] = states_count[transition_states.index(i)] + 1 # as long as not every rule is shortened to the according length, continue eliminating states while lst_or(rule_length, new_rule_length): choose_rule = random.choice(range(n)) if len(bw_rulelist[choose_rule]) == 0: continue choose_transition = random.choice(bw_rulelist[choose_rule]) idx = transition_states.index(choose_transition) if states_count[idx] > 1: bw_rulelist[choose_rule].remove(choose_transition) states_count[idx] = states_count[idx] - 1 rule_length[choose_rule] = rule_length[choose_rule] - 1 # translate rules to string rules = ['' for i in range(n)] for k in range(n): ruletext = [] for j in range(len(bw_rulelist[k])): ruletext.append(' & '.join([ '{}{}'.format('' if bw_rulelist[k][j][i] == 1 else ' ~', symbols[i]) for i in range(n) ])) ruletext[j] = "(" + ruletext[j] + ")" if ruletext != []: rules[k] = ' | '.join(ruletext) rules[k] = "Xor((" + rules[k] + "), " + symbols[k] + ")" rules[k] = parse_expr(rules[k]) rules[k] = to_dnf(rules[k], True) rules[k] = str(rules[k]).replace('&', 'and').replace( '|', 'or').replace('~', 'not ') else: rules[k] = symbols[k] rulefilelist[sim] = rulefilelist[sim] + '1: {}* = {}'.format( symbols[k], rules[k]) + '\n' with open("rule_sets.json", "w") as fs: fs.write(json.dumps(rulefilelist, indent=2)) fs.close()
# generate graph w = 12 h = 9 d = 100 plt.figure(figsize=(w, h), dpi=d) G = networkx.Graph() G.add_edges_from(edges) G.add_nodes_from(nodes) start_time = time.time() # compute number of MISs E = parse_expr(edges[0][0] + "|" + edges[0][1]) for i in range(1, len(edges)): E = E & (parse_expr(edges[i][0] + "|" + edges[i][1])) E = to_dnf(E, simplify=True, force=True) expr = (' ' + str(E) + ' ').split("|") print("\nnumber of MISs in this graph: ", len(expr)) # find MISs temp = "" temp1 = [] MIS = [] for i in range(len(expr)): temp2 = [' ' + j + ' ' for j in nodes] temp = expr[i][1] if len(expr[i]) == 3 else expr[i][2:len(expr[i]) - 2] temp1 = (' ' + temp + ' ').split("&") temp2 = [item for item in temp2 if item not in temp1] temp1 = [] MIS.append(temp2) print("MISs in this graph: ")
for v,b in zip(dependent, conj): if b == '0': rules_np[i][j][0] |= 1 << v elif b == '1': rules_np[i][j][1] |= 1 << v return rules_np interpret_logicalP = partial(interpret_logical,P) rules_sym = {head : to_dnf(body, simplify=True) for head,body in paper_rules.items()} rules_logical = [r[1] for r in sorted(paper_rules.items(), key=lambda x: int(P[str(x[0])]))] rules_logical2 = [to_dnf(r) for r in rules_logical] rules = rules_rep(P, rules_sym, same_k = True) max_k = max(dnf_len(dnf) for dnf in rules_sym.values()) def all_clauses(n_vars): return ( (x,y) for (x,y) in product(np.arange(2**n_vars, dtype=np.uint32), repeat=2) if x & y == Z and x | y) def all_dnfs(n_vars, k): return map(np.array, product(all_clauses(n_vars), repeat=k))
def test_issue_19114(): expr = (B & C) | (A & ~C) | (~A & ~B) # Expression is minimal, but there are multiple minimal forms possible res1 = (A & B) | (C & ~A) | (~B & ~C) result = to_dnf(expr, simplify=True) assert result in (expr, res1)
def parse_query(query: str) -> Any: return to_dnf(sympify(query))
def dnf(): from sympy.logic.boolalg import to_dnf from sympy.abc import A, B, C expr = input(("Enter a logic expression to perform DNF operation")) print(to_dnf(expr))
reb = input("Введите введите выражение целиком: ") reb = reb.replace('1', 'A') reb = reb.replace('2', 'B') reb = reb.replace('3', 'C') reb = reb.replace('4', 'D') reb = reb.replace('5', 'F') reb = reb.replace('6', 'G') reb = reb.replace('7', 'H') reb = reb.replace('v', '|') reb = reb.replace(')(', ')&(') reb = reb.replace('-', '~') i = 0 print(reb) print(restylec(to_dnf(reb, True))) #TODO ЧТЕНИЕ С ФАЙЛА И ДОКИНУТЬ ВАРИАНТЫ ПЕРЕМЕННЫХ НА ВХОДЕ (х1,х2,х3...) или (у1,у2, у3...) или я хз еще как но надо добавить if resh == "4": f = open("f.txt") for line in f: reb = line reb = reb.replace('1', 'A') reb = reb.replace('2', 'B') reb = reb.replace('3', 'C') reb = reb.replace('4', 'D') reb = reb.replace('5', 'F') reb = reb.replace('6', 'G') reb = reb.replace('7', 'H') reb = reb.replace('v', '|') reb = reb.replace(')(', ')&(')
from sympy.logic.boolalg import ITE, And, Xor, Or from sympy.logic.boolalg import to_cnf, to_dnf from sympy.logic.boolalg import is_cnf, is_dnf from sympy.abc import A, B, C from sympy.abc import X, Y, Z from sympy.abc import a, b, c ITE(True, False, True) ITE(Or(True, False), And(True, True), Xor(True, True)) ITE(a, b, c) ITE(True, a, b) ITE(False, a, b) ITE(a, b, c) to_cnf(~(A | B) | C) to_cnf((A | B) & (A | ~A), True) to_dnf(Y & (X | Z)) to_dnf((X & Y) | (X & ~Y) | (Y & Z) | (~Y & Z), True) is_cnf(X | Y | Z) is_cnf(X & Y & Z) is_cnf((X & Y) | Z) is_cnf(X & (Y | Z)) is_dnf(X | Y | Z) is_dnf(X & Y & Z) is_dnf((X & Y) | Z) is_dnf(X & (Y | Z))
print(Implies(False, False)) print(Implies(True, True)) print(Implies(False, True)) #cnf from sympy.logic.boolalg import to_cnf from sympy.abc import A, B, D print(to_cnf(~(A | B) | D)) print(to_cnf((A | B) & (A | ~A), True)) #dnf from sympy.logic.boolalg import to_dnf from sympy.abc import A, B, C print(to_dnf(B & (A | C))) print(to_dnf((A & B) | (A & ~B) | (B & C) | (~B & C), True)) #to check cnf and dnf from sympy.logic.boolalg import is_cnf from sympy.abc import A, B, C from sympy.logic.boolalg import is_dnf from sympy.abc import A, B, C print(is_cnf(A | B | C)) print(is_cnf((A & B) | C)) print(is_dnf(A | B | C)) print(is_dnf(A & (B | C))) #simplify logic
def select_n_formulas(self, blocked_formulas, amount_of_formulas): return sorted(blocked_formulas, key=lambda formula: len(to_dnf(formula).args))[:amount_of_formulas]
def convert_symbolic_rules_to_dnf(nid_to_symbolic_rule, simplify=False): return {nid: boolalg.to_dnf(rule, simplify=simplify) for nid, rule in iteritems(nid_to_symbolic_rule)}
stack.pop() return ltinlt def delExtraNOT(str): coord = bracketsDestination(str) letterList = [] for i in coord: letterList.append("".join(re.findall(" [A-Z] ", str[i[0] : i[1]] ))) print(letterList) tmp = 1 for j in range(0, len(letterList)-1): if letterList[j] == letterList[j+1]: letterList[j] = letterList[j+1] = '' #TODO: delete brackets here str = remove_character(str, coord[j][0]) str = remove_character(str, coord[j][1]) str = remove_character(str, coord[j+1][0]) str = remove_character(str, coord[j+1][1]) print(str) # Simplification and calling the functions aka main boolExpr = input("print some boolean expressions: ") SimpleDNF = to_dnf(boolExpr, True).__str__() print("Simplification is ",SimpleDNF) print("Expression using NAND and NOT gates is ",disjParts(conjParts(partsOf(SimpleDNF)))) print(bracketsDestination('NOT ( NOT ( NOT ( D NAND C ) NAND B ) ) NAND NOT ( A )')) delExtraNOT(disjParts(conjParts(partsOf(SimpleDNF)))) #TODO: mdy delete repeated NOT, mby no mby f**k you
def main(modeltext, desiredAttr): modeltext = modeltext.strip() # Split the modeltext by line modeltextLine = modeltext.splitlines() # Convert the desiredAttr to dictionary data type desiredAttrDic = {} s = 0 for line in modeltextLine: IODic = line.split("=") desiredAttrDic[IODic[0].strip()] = str(bool(int(desiredAttr[s]))) s = s + 1 # Set logic symbols and_logic = ["and", "&&"] or_logic = ["or", "||"] negation_logic = ["not"] # Convert each logic expression to disjunctive normal form(DNF) formatTransformG = "" formatTransformAllPlus = "" formatFVS_ori = "" inputNodeList = [] for line in modeltextLine: # Convert given logic symbols to official symbols and_rep = replaceMultiple(line, and_logic, "&") or_rep = replaceMultiple(and_rep, or_logic, "|") negation_rep = replaceMultiple(or_rep, negation_logic, "~") str1 = negation_rep.split("=") expression = str1[1].strip() # Extract nodes from each logic expression and create one list logicList = re.findall(r'\w+', negation_rep) logicOutput = logicList[0] logicInput = logicList[1:] # Remove duplicates in list logicInput = [x for i, x in enumerate(logicInput) if i == logicInput.index(x)] # print(logicOutput, logicInput[0]) if logicInput[0] == "_INPUT_": inputNodeList.append(logicOutput) continue for node in logicInput: # Input negation if desiredAttrDic[node] == "False": # Exact replacement using regular expression expression = re.sub(r"\b" + node + r"\b", "( ~ " + node + ")", expression) # Output negation if desiredAttrDic[logicOutput] == "False": expression = expression.replace(expression, " ~ ( " + expression + ")") # print(expression) expressionDnf = to_dnf(expression, True) # Build all G network transformedLogicG = logicOutput + " = " + str(expressionDnf) formatTransformG = formatTransformG + transformedLogicG + "\n" # Build all plus products network plusProductSep = " | " x = str(expressionDnf).split("|") plusProductList = [] for i in x: if not ("~") in i: plusProductList.append(i.strip()) termSelected = plusProductSep.join(plusProductList) #print(termSelected) transformedLogicAllPlus = logicOutput + " = " + termSelected formatTransformAllPlus = formatTransformAllPlus + transformedLogicAllPlus + "\n" # Set formatFVS_ori for v in logicInput: formatFVS_ori = formatFVS_ori + logicOutput + ", " + v + "\n" return formatTransformG, formatTransformAllPlus, formatFVS_ori, inputNodeList
def hoftask(init, buchi_graph, regions, r): h_task = DiGraph(type='subtask') try: label = to_dnf( buchi_graph.edges[(buchi_graph.graph['init'][0], buchi_graph.graph['init'][0])]['label'], True) except KeyError: # no self loop label = to_dnf('0') init_node = State((init, buchi_graph.graph['init'][0]), label) h_task.add_node(init_node) open_set = list() open_set.append((init_node, '0')) explore_set = list() # if q1 --label--> q2, [target(label), q1]:q2 succ_dict = dict() succ_dict[(init_node, '0')] = {buchi_graph.graph['init'][0]} task_group = dict() while open_set: curr = open_set.pop(0) # buchi state that curr corresponds to for q_target in succ_dict[curr]: try: label = to_dnf( buchi_graph.edges[(q_target, q_target)]['label'], True) except KeyError: # no self loop label = to_dnf('0') for q_b in buchi_graph.succ[q_target]: if q_b != q_target: # region corresponding to the label/word edge_label = (buchi_graph.edges[(q_target, q_b)]['label']) if edge_label == '(1)': x_set = [curr[0].x] elif '~' in edge_label and to_dnf(edge_label).nargs == { 1 }: # ~l3_1 if curr[0].x == regions[to_dnf( edge_label).args[0].name.split('_')[0]]: x_set = [(curr[0].x[0], curr[0].x[1] - r)] else: x_set = [curr[0].x] else: x_set = target(to_dnf(edge_label), regions) if x_set: for x in x_set: cand = State((x, q_target), label) # seems no need to check # if curr[0] != cand and not match(h_task, curr[0], cand): if not match(h_task, curr[0], cand): h_task.add_edge(curr[0], cand) try: task_group[curr[0].x].add((curr[0], cand)) except KeyError: task_group[curr[0].x] = {(curr[0], cand)} try: succ_dict[(cand, edge_label)].add(q_b) except KeyError: succ_dict[(cand, edge_label)] = {q_b} if (cand, edge_label) not in open_set and ( cand, edge_label) not in explore_set: open_set.append((cand, edge_label)) h_task.add_node(cand) explore_set.append(curr) return h_task, task_group