def prepareStatement(izjava): # Metoda sprejme izjavo in jo pripravi takole: # - izjavo pretvori v CNF obliko # - izjavo pretvori v seznam seznamov oblike [ ... [ ... ] ...] # - odstrani vse proste spremenljivke # - preveri, da se ne zgodi primer (X and notX) # - pobrise vse True izjave oblike (X or notX) # - najde vse proste spremenljivke # Metoda vrne seznam, v katerem je izjava in vrednosti spremenljivk # Ce je primer na osnovi zgornjih ugotovitev neresljiv, potem metoda vrne False # poresetiram prejsno resitev global solutionVals global lockSolutionVals global newPureValFound solutionVals = {} lockSolutionVals = False newPureValFound = True izjava = CNF(izjava) # pretvori izjavo v CNF izjava = izjava.poenostavi().vrni() # dobim [ ... (...) ...] izjava = get_2D_list(izjava) # dobim [ ... [...] ...] varValues = {} # Zacetne vrednosti spremenljivk izjava = removeTrueSantences(izjava) # metoda odstrani podizjave tipa (X or notX) .... TODO: ali to pravilno deluje? izjava = sortByLength(izjava) # PREVERJAMO PROSTE SPREMENLJIVKE, DOKLER JE KAKsNA SE PROSTA!! while (True): changes = 0 # stevec za ustavitveni pogoj newVarDict = {} newVarDict = removeSingleVars(izjava) if (newVarDict == False): print('ERROR: getInfo[1] == False ..... returning False!!!') return False else: varValues = concatDicts(varValues, newVarDict) if varValues == False: # ce je prislo do protislovja (X and notX) potem ni resitve in vrnemo False print('ERROR: varValues == False ..... returning False!!!') return False izjava = processStatement(izjava, varValues) # metoda odstrani OR-e, ki so True in spremenljivke znotraj OR-ov, ki so False if (newVarDict != {}): changes = changes + 1 if (changes == 0): break # PREVERIMO CISTE SPREMENLJIVKE # Spodnja while zanka pridobiva ciste spremenljivke, poenostavlja izjavo in to ponavalja, dokler je kaksna spremenljivka cista while (newPureValFound == True): pureVals = getPureVals(izjava) # pridobim slovar cistih spremenljivk varValues = concatDicts(varValues, pureVals) # zdruzim obstojece spremenljivke s cistimi #preverimo, da nismo prisli do protislovja: if varValues == False: return False izjava = processStatement(izjava, varValues) # metoda odstrani OR-e, ki so True in spremenljivke znotraj OR-ov, ki so False izjava = sortByLength(izjava) # sortiranje izjave po dolzini podizjav (narascajoce) # vrnemo seznam, ki vsebuje na rekurzijo pripravljeno izjavo in slovar vrednosti spremenljivk (te niso vec zastopane v izjavi) return [izjava, varValues]
def main(): test = copy.deepcopy(CNF.EXAMPLE2) CNF.resolveTillNegation(test) print(test) return None
def convert_grammar(self, grammar): """ Read a CFG from the given file, converts it to CNF ,stores it in self.grammar and shows it in new_grammar.txt. :param grammar: the file in which the grammar is stored. """ self.grammar = CNF.convert_grammar(CNF.read_grammar(grammar)) new_grammar = CNF.convert_grammar(CNF.read_grammar(grammar)) with open('cnf_grammar.txt', 'w') as fw: for rules in new_grammar: rules.insert(1, '->') s = ' '.join(rules) + '\n' fw.write(s)
def valuacija(): ## s = [[5,3,0,0,7,0,0,0,0],[6,0,0,1,9,5,0,0,0],[0,9,8,0,0,0,0,6,0],[8,0,0,0,6,0,0,0,3],[4,0,0,8,0,3,0,0,1],[7,0,0,0,2,0,0,0,6],[0,6,0,0,0,0,2,8,0],[0,0,0,4,1,9,0,0,5],[0,0,0,0,8,0,0,7,9]] ## s_r = [[5,3,4,6,7,8,9,1,2],[6,7,2,1,9,5,3,4,8],[1,9,8,3,4,2,5,6,7],[8,5,9,7,6,1,4,2,3],[4,2,6,8,5,3,7,9,1],[7,1,3,9,2,4,8,5,6],[9,6,1,5,3,7,2,8,4],[2,8,7,4,1,9,6,3,5],[3,4,5,2,8,6,1,7,9]] s = [[1,2,0,0],[3,0,1,0],[0,1,0,3],[0,0,2,1]] s_r = [[1,2,3,4],[3,4,1,2],[2,1,4,3],[4,3,2,1]] sud = sudoku(s) sudCNF = CNF(sud) sudCNFp = sudCNF.poenostavi() spremen = sud.var() val = {} for x in spremen: ime = x.vrni_ime() i = int(ime[2]) j = int(ime[4]) n = int(ime[6]) if s_r[i][j]==n: val[x]= True else: val[x]= False print(sud.izracun(val)) print(sudCNF.izracun(val)) print(sudCNFp.izracun(val))
def valuacija(): #h = [[1,1],[1,-1]] h = 2 had = hadamard(h) hadCNF = CNF(had) hadCNFp = hadCNF.poenostavi() spremen = had.var() val = {} for x in spremen: ime = x.vrni_ime() i = int(ime[2]) j = int(ime[4]) if len(ime) == 9: n = int(ime[6]+ime[7]) else: n = int(ime[6]) if h[i][j]==n: val[x]= True else: val[x]= False print(had.izracun(val)) print(hadCNF.izracun(val)) print(hadCNFp.izracun(val))
class SATModerno_fromFormula: def __init__(self): self.cnf = CNF() def runPySAT_fromFormula(self, formula): list_clauses = [] relationAndClauses = self.cnf.formulaToCNFClauses(formula) clauses = list(relationAndClauses.get("clauses")) glucose = Glucose3() for clause in clauses: list_clauses.append(list(clause)) glucose.append_formula(list_clauses) return glucose.solve()
def __init__(self): self.cnf = CNF()
def R2(): for n in Table: n["=>R2"] = CNF.valueConverter(n, ["NOT","OR","P","Q"], presentVariables)
# file='Benchmark Problems//uf75-067.cnf' # file='Benchmark Problems//uf75-01.cnf' # file='Benchmark Problems//uf50-082.cnf' # file='Benchmark Problems//uf50-050.cnf' # file='Benchmark Problems//uf50-010.cnf' # file='Benchmark Problems//uf20-050.cnf' file = 'Benchmark Problems//uf20-029.cnf' # outputfile='Export//uf75-073.txt' # outputfile='Export//uf75-067.txt' # outputfile='Export//uf75-01.txt' # outputfile='Export//uf50-082.txt' # outputfile='Export//uf50-050.txt' # outputfile='Export//uf50-010.txt' # outputfile='Export//uf20-050.txt' outputfile = 'Export//uf20-029.txt' formulas = CNF.readCnf(file) runner = Cnfsolver.Cnfsolver(formulas) sum = 0 sumGen = 0 for run in range(0, 20, 1): success_rate, solution, generation = runner.solver() print('success_rate:', str(success_rate) + '\n', 'solution:', str(solution) + '\n', 'Generation:', generation) sum = sum + success_rate sumGen = sumGen + generation avg_success_rate: float = sum / 20 avg_Generation: float = sumGen / 20 print('Average success rate:', avg_success_rate) f = open(outputfile, 'w+') f.write('Avg_Generation:%d\r\n' % avg_Generation)
class DPLL: def __init__(self): self.cnf = CNF() def runFromFile(self, filePath): clauses = self.cnf.readCNFFile(filePath) return self.__dpllRecursion(clauses, set()) def runFromFormula(self, formula): relationAndClauses = self.cnf.formulaToCNFClauses(formula) relation = relationAndClauses.get("relation") clauses = relationAndClauses.get("clauses") result = self.__dpllRecursion(clauses, set()) if not result: return result valuation = dict() for literal in result: if literal > 0: valuation[relation.get(literal)] = True else: valuation[relation.get(abs(literal))] = False return valuation def __dpllRecursion(self, clauses, valuation): clauses, valuation = self.__unitPropagation(clauses, valuation) if len(clauses) == 0: return valuation if self.__hasEmptyClause(clauses): return False literal = self.__getLiteral(clauses) clausesFirstCase = clauses.union({frozenset([literal])}) clausesSecondCase = clauses.union({frozenset([literal * -1])}) result = self.__dpllRecursion(clausesFirstCase, valuation) if result: return result return self.__dpllRecursion(clausesSecondCase, valuation) def __unitPropagation(self, clauses, valuation): unitaryClause = self.__getUnitaryClause(clauses) while unitaryClause is not None: clauses.remove(unitaryClause) valuation = valuation.union(unitaryClause) literal = list(unitaryClause)[0] toRemove = set() newCalsues = set() for clause in clauses: if literal in clause: toRemove.add(clause) continue inversedLiteral = literal * -1 if inversedLiteral in clause: # print(literal) newClause = clause.difference({inversedLiteral}) # print(clause, newClause) newCalsues.add(frozenset(newClause)) if len(newClause) == 0: clauses = clauses.difference(toRemove).union( newCalsues) return clauses, valuation clauses = clauses.difference(toRemove).union(newCalsues) toRemove.clear() newCalsues.clear() unitaryClause = self.__getUnitaryClause(clauses) return clauses, valuation def __getUnitaryClause(self, clauses): for clause in clauses: if len(clause) == 1: return clause return None def __hasEmptyClause(self, clauses): for clause in clauses: if len(clause) == 0: return True return False def __getLiteral(self, clauses): smaller = None for clause in clauses: if smaller is None: smaller = clause continue if len(clause) < len(smaller): smaller = clause return list(smaller)[0]
class Resolution: def __init__(self): self.cnf = CNF() def runFromFile(self, filePath): clauses = self.cnf.readCNFFile(filePath) return self.__resolutionMethod(clauses) def runFromFormula(self, formula): clause = self.cnf.formulaToCNFClauses(formula) return self.__resolutionMethod(clauses) def __resolutionMethod(self, clauses): clauses = self.__removeTrivialClauses(clauses) for currentClause in clauses: for clause in clauses: if currentClause == clause: continue trivialLiteral = self.__getTrivialLiteral( currentClause, clause) if trivialLiteral: currentClauseCopy = set(currentClause) currentClauseCopy.remove(trivialLiteral) clauseCopy = set(clause) clauseCopy.remove((trivialLiteral * -1)) newClause = frozenset(currentClauseCopy.union(clauseCopy)) if not len(newClause): return False setClauses = set(clauses) setClauses.add(newClause) clauses = list(setClauses) if len(clauses) > 0: return set(clauses) return True def __removeTrivialClauses(self, clauses): for clause in clauses: if self.__isTivialClause(clause): clauses.remove(clause) return clauses def __isTrivialClause(self, clause): for literal in clause: if (literal * -1) in clause: return True return False def __getTrivialLiteral(self, currentClause, clause): trivialLiteral = None for literal in currentClause: if (literal * -1) in clause: if trivialLiteral is None: trivialLiteral = literal else: trivialLiteral = None break return trivialLiteral
C = litteral(True) D = litteral("c") E = litteral(False) F = litteral("-d") G = litteral("-a") A1 = clause([A, B, B]) A2 = clause([]) A3 = clause([B, C, D]) A4 = clause([D, E, F]) A5 = clause([A, B, D, F, G]) A6 = clause([A]) A7 = clause([E]) A8 = clause([C, A, D, E]) B1 = CNF([A2]) B2 = CNF([A1, A1]) B3 = CNF([A1, A3]) B4 = CNF([A3, A4, A5]) B5 = CNF([A1, A5]) B6 = CNF([A1, A4, A6, A8]) B7 = CNF([A1, A6, A7]) # Exemples du cours l1 = [['-c', 'd', '-b', '-a'], ['c', 'd', '-b', '-a']] l2 = [['-p', 's'], ['q', 'r'], ['q', 'p', 's'], ['-r', '-p', '-q'], ['-r', '-s', '-q']] l = l2 clauses = [] for cl in l:
df["single"] = df.apply(lambda x: (abs(x["f+"] - x["f-"]) <= 1e-6), axis=1) if (True in set(df["single"])) and (False not in set(df["single"])): single = True else: single = False # discretize the frequencies df["f+int"] = df["f+"].apply(lambda x: int(math.floor(x * (2**N - 1)))) #df["f+bin"]=df["f+int"].apply( lambda x: bin(x)[2:] ) df["f-int"] = df["f-"].apply(lambda x: int(math.floor(x * (2**N - 1)))) #df["f-bin"]=df["f-int"].apply( lambda x: bin(x)[2:] ) # Initialize the CNF class F = CNF.CNF() def to_bin_list(val, n_bits=N): # Convert a integer to a vector of binary values lb = bin(val)[2:][::-1] ans = [] for i in range(N): if i < len(lb): ans.append(1 if lb[i] == "1" else -1) else: ans.append(-1) return ans r_var = [F.new_var() for p in range(n)] # variables indicating root node