def test_is_cnf(): x, y, z = symbols('x,y,z') assert is_cnf(x) is True assert is_cnf(x | y | z) is True assert is_cnf(x & y & z) is True assert is_cnf((x | y) & z) is True assert is_cnf((x & y) | z) is False
def expr_to_satfmt(expr, mapper, convert_cnf=True): """ Takes a sympy formula in CNF, return a list of lists of integers for use with pycosat """ # ensure CNF cnf_expr = None if convert_cnf and not is_cnf(expr): print( "Got a non-CNF expression, converting... (depending on the size and " "structure of the expression, this could take a prohibitively long time)" ) # see https://cs.stackexchange.com/a/41071/97082 for an explanation # if this becomes a problem, Tseitin transforms might be worth exploring # for now I'm just gonna try to stick to CNF everywhere cnf_expr = to_cnf(expr, simplify=True, force=True) else: cnf_expr = expr # make list of lists of integers clauses = [] for clause in cnf_expr.args: if type(clause) in [Symbol, Not]: clauses.append([mapper.to_int(clause)]) else: clauses.append(list(map(mapper.to_int, clause.args))) return clauses
def addToKnowledgeBase(self, box): expression_box_neighbours = S.false neighbours = self.getNeighbours(box) if box.clue == 0: for neighbour in neighbours: if neighbour in self.fringe: self.fringe.remove(neighbour) # neighbour.solved = True # self.solvedBoxes += 1 self.knowledgeBase = self.knowledgeBase.subs( {neighbour.symbol: False}) if (neighbour.solved == False): self.observedMineField[neighbour.row][ neighbour.col].prob = 0.0 self.fringe.append(neighbour) elif box.clue == 8: for neighbour in neighbours: if neighbour in self.fringe: self.fringe.remove(neighbour) neighbour.solved = True neighbour.mineFlag = IS_MINE self.solvedBoxes += 1 # self.unseenBoxes -= 1 self.knowledgeBase = self.knowledgeBase.subs( {neighbour.symbol: True}) self.observedMineField[neighbour.row][neighbour.col].prob = 1.0 else: for ci in range(0, box.clue + 1): for subset in itertools.combinations(neighbours, box.clue): expression_subset = S.true for neighbour in neighbours: if neighbour not in subset: expression_subset = expression_subset & ~neighbour.symbol else: expression_subset = expression_subset & neighbour.symbol expression_box_neighbours = expression_box_neighbours | ( expression_subset) for neighbour in neighbours: if neighbour.solved == True: if neighbour.mineFlag: expression_box_neighbours = expression_box_neighbours.subs( {neighbour.symbol: True}) else: expression_box_neighbours = expression_box_neighbours.subs( {neighbour.symbol: False}) # print("Expression Generated:", expression_box_neighbours) expr = expression_box_neighbours if not is_cnf(expr): expr = to_cnf(expr, simplify=True) # print("Converted new expression") # print("After CNF:", expr) self.updateKnowledgeBase(expr, box)
def addInfoToKnowledgeBase(self, box): expression_box_neighbours = S.false neighbours = self.getNeighbours(box) if box.clue == 0: for neighbour in neighbours: if neighbour in self.fringe: self.fringe.remove(neighbour) # neighbour.solved = True # self.solvedBoxes += 1 self.knowledgeBase = self.knowledgeBase.subs( {neighbour.denotation: False}) if (neighbour.solved == False): self.agentObservedMineField[neighbour.row][ neighbour.col].prob = 0.0 self.fringe.append(neighbour) elif box.clue == 8: for neighbour in neighbours: if neighbour in self.fringe: self.fringe.remove(neighbour) neighbour.solved = True neighbour.mineFlag = IS_MINE self.solvedBoxes += 1 # self.unseenBoxes -= 1 self.knowledgeBase = self.knowledgeBase.subs( {neighbour.denotation: True}) self.agentObservedMineField[neighbour.row][ neighbour.col].prob = 1.0 else: for clue_i in range(0, box.clue + 1): for subset in itertools.combinations(neighbours, box.clue): expression_subset = S.true for neighbour in neighbours: if neighbour not in subset: expression_subset = expression_subset & ~neighbour.denotation else: expression_subset = expression_subset & neighbour.denotation expression_box_neighbours = expression_box_neighbours | ( expression_subset) for neighbour in neighbours: if neighbour.solved: if neighbour.mineFlag: expression_box_neighbours = expression_box_neighbours.subs( {neighbour.denotation: True}) else: expression_box_neighbours = expression_box_neighbours.subs( {neighbour.denotation: False}) expression = expression_box_neighbours if not is_cnf(expression): expression = to_cnf(expression, simplify=True) self.updateKnowledgeBaseInfo(expression, box)
def test_issue_18904(): x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 = symbols('x1:16') eq = (( x1 & x2 & x3 & x4 & x5 & x6 & x7 & x8 & x9 ) | ( x1 & x2 & x3 & x4 & x5 & x6 & x7 & x10 & x9 ) | ( x1 & x11 & x3 & x12 & x5 & x13 & x14 & x15 & x9 )) assert is_cnf(to_cnf(eq)) raises(ValueError, lambda: to_cnf(eq, simplify=True)) for f, t in zip((And, Or), (to_cnf, to_dnf)): eq = f(x1, x2, x3, x4, x5, x6, x7, x8, x9) raises(ValueError, lambda: to_cnf(eq, simplify=True)) assert t(eq, simplify=True, force=True) == eq
def test_is_cnf(): assert is_cnf(x) is True assert is_cnf(x | y | z) is True assert is_cnf(x & y & z) is True assert is_cnf((x | y) & z) is True assert is_cnf((x & y) | z) is False assert is_cnf(~(x & y) | z) is False
def _process_expr(self): self._num_vars = len(self._expr.binary_symbols) self._lit_to_var = [None] + sorted(self._expr.binary_symbols, key=str) self._var_to_lit = dict( zip(self._lit_to_var[1:], range(1, self._num_vars + 1))) if self._optimization or (not is_cnf(self._expr) and not is_dnf(self._expr)): expr = simplify_logic(self._expr) else: expr = self._expr if isinstance(expr, BooleanTrue): ast = 'const', 1 elif isinstance(expr, BooleanFalse): ast = 'const', 0 else: ast = get_ast(self._var_to_lit, expr) if ast[0] == 'or': self._nf = DNF(ast, num_vars=self._num_vars) else: self._nf = CNF(ast, num_vars=self._num_vars)
def add_premise(self, sentence): """ :param sentence: sentence to be added :param rank: rank corresponding to sentence. :return: """ if not is_cnf(sentence): sentence = to_cnf(sentence) premises = self.fetch_premises() if not PL_resolution(premises, sentence): logging.warning( f'{sentence} introduces a contradiction in the KB.') # return None if sentence in premises: logging.warning(f'{sentence} was already part of the KB.') return sentence premises.append(sentence) updated_ranks = self.update_ranks_of_existing_premises(premises) self.premises = [ (belief, rank) for belief, rank in zip(premises, updated_ranks) ] #zip updated ranks and premises and store in return sentence
def addInfoToKnowledgeBase(self, box): expression_box_neighbours = S.false neighbours = self.getNeighbours(box) # CASE 1: The clue is 0 i.e. all neighbours are 'SAFE if box.clue == 0: for neighbour in neighbours: if neighbour in self.fringe: self.fringe.remove(neighbour) # neighbour.solved = True # self.solvedBoxes += 1 self.knowledgeBase = self.knowledgeBase.subs( {neighbour.denotation: False}) if (neighbour.solved == False): self.agentObservedMineField[neighbour.row][ neighbour.col].prob = 0.0 self.fringe.append(neighbour) # CASE 2: 100 percent confidence in all the neighbours being a mine elif box.clue == 8: for neighbour in neighbours: if neighbour in self.fringe: # As 'Pass by Value' is being used here self.fringe.remove(neighbour) neighbour.solved = True neighbour.mineFlag = IS_MINE self.solvedBoxes += 1 self.knowledgeBase = self.knowledgeBase.subs( {neighbour.denotation: True}) self.agentObservedMineField[neighbour.row][ neighbour.col].prob = 1.0 # CASE 3: The clue lies between 0 and 1 (exclusive) else: for subset in itertools.combinations(neighbours, box.clue): expression_subset = S.true # Forming the expression for the neighbours of a given box for neighbour in neighbours: if neighbour not in subset: expression_subset = expression_subset & ~neighbour.denotation else: expression_subset = expression_subset & neighbour.denotation expression_box_neighbours = expression_box_neighbours | expression_subset # Updating the expression obtained above for neighbour in neighbours: if neighbour.solved: if neighbour.mineFlag: expression_box_neighbours = expression_box_neighbours.subs( {neighbour.denotation: True}) else: expression_box_neighbours = expression_box_neighbours.subs( {neighbour.denotation: False}) # print("Expression Generated:", expression_box_neighbours) expression = expression_box_neighbours if not is_cnf(expression): expression = to_cnf(expression, simplify=True) # print("Converted new expression") # print("After CNF:", expr) self.updateKnowledgeBaseInfo(expression, box)
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))
def test_issue_9949(): assert is_cnf(to_cnf((b > -5) | (a > 2) & (a < 4)))
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 from sympy.logic import simplify_logic from sympy.abc import x, y, z from sympy import S b = (~x & ~y & ~z) | (~x & ~y & z) print(simplify_logic(b))
def test_is_cnf(): x, y, z = symbols('xyz') assert is_cnf(x | y | z) == True assert is_cnf(x & y & z) == True assert is_cnf((x | y) & z) == True assert is_cnf((x & y) | z) == False
def checkcnf(): from sympy.logic.boolalg import is_cnf from sympy.abc import A, B, C expr = input(("Enter a logic expression to check for CNF")) print(is_cnf(expr))