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
