def skip(s): p = prog(s, "skip") x, y = elms("x y") s.add(ForAll([x, y], And(p.set(x), p.pre(x), p.post(x, y) == (x == y)))) return p
def main(): """Battleship solver example.""" sg = grilops.SymbolGrid(LATTICE, SYM) sc = grilops.shapes.ShapeConstrainer( LATTICE, [ [Vector(0, i) for i in range(4)], [Vector(0, i) for i in range(3)], [Vector(0, i) for i in range(3)], [Vector(0, i) for i in range(2)], [Vector(0, i) for i in range(2)], [Vector(0, i) for i in range(2)], [Vector(0, i) for i in range(1)], [Vector(0, i) for i in range(1)], [Vector(0, i) for i in range(1)], ], solver=sg.solver, allow_rotations=True ) # Constrain the given ship segment counts and ship segments. for y, count in enumerate(GIVENS_Y): sg.solver.add( PbEq([(Not(sg.cell_is(Point(y, x), SYM.X)), 1) for x in range(WIDTH)], count) ) for x, count in enumerate(GIVENS_X): sg.solver.add( PbEq([(Not(sg.cell_is(Point(y, x), SYM.X)), 1) for y in range(HEIGHT)], count) ) for p, s in GIVENS.items(): sg.solver.add(sg.cell_is(p, s)) for p in LATTICE.points: shape_type = sc.shape_type_grid[p] shape_id = sc.shape_instance_grid[p] touching_types = [ n.symbol for n in LATTICE.vertex_sharing_neighbors(sc.shape_type_grid, p) ] touching_ids = [ n.symbol for n in LATTICE.vertex_sharing_neighbors(sc.shape_instance_grid, p) ] # Link the X symbol to the absence of a ship segment. sg.solver.add( (sc.shape_type_grid[p] == -1) == sg.cell_is(p, SYM.X)) # Ship segments of different ships may not touch. and_terms = [] for touching_id in touching_ids: and_terms.append( Implies( shape_id >= 0, Or(touching_id == shape_id, touching_id == -1) ) ) sg.solver.add(And(*and_terms)) # Choose the correct symbol for each ship segment. touching_count_terms = [(c == shape_type, 1) for c in touching_types] sg.solver.add( Implies( And(shape_type >= 0, PbEq(touching_count_terms, 2)), sg.cell_is(p, SYM.B) ) ) sg.solver.add( Implies( And(shape_type >= 0, PbEq(touching_count_terms, 0)), sg.cell_is(p, SYM.O) ) ) for n in sg.edge_sharing_neighbors(p): sg.solver.add( Implies( And( shape_type >= 0, PbEq(touching_count_terms, 1), sc.shape_type_grid[n.location] == shape_type ), sg.cell_is(p, DIR_TO_OPPOSITE_SYM[n.direction]) ) ) if sg.solve(): sg.print() print() sc.print_shape_instances() print() if sg.is_unique(): print("Unique solution") else: print("Alternate solution") sg.print() print() sc.print_shape_instances() print() else: print("No solution")
def toZ3(self): var = Z3VarTable.get(self.var) if (isinstance(self.value, IP)): ips = self.value.get_range() return And(var >= ips[0], var <= ips[1]) return (var == self.value.value)
from z3 import Solver, Ints, And, sat s = Solver() # Declare three integer variables/constants of Z3Py {x, y, z} : x, y, z = Ints('x y z') # Assert that {x, y, z} are positive integers such that 0 < x < y < z : s.add(And(0 < x, x < y, y < z)) # Assert that x*x + y*y = z*z, i.e. (x,y,z) is a Pythagorean triple : s.add(x % 2 != 0) s.add(y % 2 == 0) s.add(y == z - 1) s.add(x * x + y * y == z * z) n = 1 results = [] while s.check() == sat and n <= 3: m = s.model() results.append(m) s.add(x != m[x]) n = n + 1 # print len (results) for p in range(len(results)): print(results[p])
def reencode_quantifiers(expr, boundvariables, quantifiers): z3.set_option(max_args=10000000, max_lines=1000000, max_depth=10000000, max_visited=1000000) smt2string = toSMT2Benchmark(expr) # Have to scan the string, because other methods proved to be too slow. log('Detect declarations of the free variables in SMTLIB2 string') free_variables = re.findall( '\(declare-fun (\w+) \(\) (Bool)|\(declare-fun (\w+) \(\) \(\_ BitVec (\d+)\)', smt2string) free_variables += re.findall( '\(declare-const (\w+) (Bool)|\(declare-const (\w+) \(\_ BitVec (\d+)\)', smt2string) for fv in free_variables: if str(fv).startswith('?'): print( 'Error: Variable starts with "?". Potential for confusion with quantified variables. This case is not handled.' ) exit() log(' Found {} free variables'.format(len(free_variables))) # Turn free variables into z3 variabes and add them to the quantifier for idx, (a, b, x, y) in enumerate(free_variables): assert (a != '' or x != '') if a != '': assert (b == 'Bool') free_variables[idx] = Bool(a) else: free_variables[idx] = BitVec(x, int(y)) quantifiers = [['e', free_variables]] + quantifiers log('Replacing de Bruijn indices by variables') matches = re.findall('\?(\d+)', smt2string) deBruijnIDXs = map(int, set(matches)) assert (len(deBruijnIDXs) <= len(boundvariables)) # sort de Bruijn indeces in decreasing order so that replacing smaller numbers does not accidentally match larger numbers deBruijnIDXs = list(deBruijnIDXs) deBruijnIDXs.sort() deBruijnIDXs.reverse() for idx in deBruijnIDXs: smt2string = smt2string.replace('?{}'.format(idx), str(boundvariables[-(1 + int(idx))])) log('Generating SMTLIB without quantifiers') # introduce quantified variables to enable re-parsing declarations = [] for var in boundvariables: if is_bv(var): declarations.append('(declare-fun {} () (_ BitVec {}))'.format( str(var), var.size())) else: assert (is_bool(var)) declarations.append('(declare-fun {} () Bool)'.format(str(var))) smt2string = '\n'.join(declarations) + '\n' + smt2string log('Reparsing SMTLIB without quantifiers') flat_constraints = parse_smt2_string(smt2string) # log('Extract all variables') # allvariables = get_vars(flat_constraints) # # log('Search for free variables') # freevariables = [] # known_vars = set(map(str,boundvariables)) # for idx, var in enumerate(allvariables): # if idx+1 % 10000 == 0: # log(' {} variables checked if free'.format(idx)) # if str(var) not in known_vars: # freevariables.append(var.n) # var.n because var is only the AstRefKey object # # log('Found {} free variables'.format(len(freevariables))) # # quantifiers = [['e', freevariables]] + quantifiers # delete empty quantifiers i = 0 while i < len(quantifiers): if len(quantifiers[i][1]) == 0: del (quantifiers[i]) else: i += 1 for i in range(len(quantifiers) - 1): if quantifiers[i][0] == quantifiers[i + 1][0]: mergedQuantifiers[-1][1] += quantifiers[i + 1][1] else: mergedQuantifiers += [quantifiers[i + 1]] # merge successive quantifiers of the same type if len(quantifiers) > 0: mergedQuantifiers = [quantifiers[0]] for i in range(len(quantifiers) - 1): if quantifiers[i][0] == quantifiers[i + 1][0]: mergedQuantifiers[-1][1] += quantifiers[i + 1][1] else: mergedQuantifiers += [quantifiers[i + 1]] quantifiers = mergedQuantifiers # print quantifiers return quantifiers, And(flat_constraints)
def SMT_standard_model(instance): # -------------------------- # PARAMETERS # -------------------------- # Define dimensions parameters x = 0 y = 1 # Define wrapping paper roll height and width roll_width = instance['roll_width'] roll_height = instance['roll_height'] # Define wrapping paper roll coordinates X_COORDINATES = range(roll_width) Y_COORDINATES = range(roll_height) # Define the number of pieces to cut n_pieces = instance['n_pieces'] # Define pieces as a set of integers from 0 to num. of presents-1 PIECES = range(n_pieces) # Define the dimensions of the piecesq to cut pieces_dimensions = instance['pieces_dimensions'] # Define lower and upper bounds for the dimensions lower_bounds = [0, 0] upper_bounds = [roll_width, roll_height] # -------------------------- # VARIABLES # -------------------------- # DECISION VARIABLES # Define bottom-left corner of the pieces of paper to cut as 2-D (width-height) array of int decision variables pieces_corners = [[Int("x_%s" % i), Int("y_%s" % i)] for i in PIECES] # -------------------------- # CONSTRAINTS # -------------------------- # DOMAIN CONSTRAINTS: reduce the domain for the bottom-left corners of the pieces of paper # The cut can not be done outside the paper roll: the bottom-left corner coordinates of the pieces of paper to cut # must not exceed the paper roll coordinates limit, considering also the dimension of the piece of paper domain_bound_constraints = [ And(And(pieces_corners[i][x] >= lower_bounds[x], pieces_corners[i][x] <= upper_bounds[x] - pieces_dimensions[i][x]), And(pieces_corners[i][y] >= lower_bounds[y], pieces_corners[i][y] <= upper_bounds[y] - pieces_dimensions[i][y])) for i in PIECES] # IMPLIED CUMULATIVE CONSTRAINTS: define the maximum number of usable paper # The maximum usable quantity of paper is defined by the paper roll dimensions cumulative_constraints = [Sum( [If(And(y_coord >= pieces_corners[i][y], y_coord < pieces_corners[i][y] + pieces_dimensions[i][y]), pieces_dimensions[i][x], 0) for i in PIECES]) == roll_width for y_coord in Y_COORDINATES] + [Sum( [If(And(x_coord >= pieces_corners[i][x], x_coord < pieces_corners[i][x] + pieces_dimensions[i][x]), pieces_dimensions[i][y], 0) for i in PIECES]) == roll_height for x_coord in X_COORDINATES] # NON-OVERLAPPING CONSTRAINT: define the non-overlapping property fo the pieces of paper # The cutted pieces of paper must not overlap: the bottom-left corner coordinates must not be equal to other # coordinates of the paper roll which are already occupied by other pieces of paper non_overlapping_constraints = [Or(pieces_corners[i][x] + pieces_dimensions[i][x] <= pieces_corners[j][x], pieces_corners[i][y] + pieces_dimensions[i][y] <= pieces_corners[j][y], pieces_corners[j][x] + pieces_dimensions[j][x] <= pieces_corners[i][x], pieces_corners[j][y] + pieces_dimensions[j][y] <= pieces_corners[i][y]) for i in PIECES for j in PIECES if i < j] # -------------------------- # SOLUTION # -------------------------- solver = Solver() solver.add(domain_bound_constraints + cumulative_constraints + non_overlapping_constraints) return solver, PIECES, pieces_corners
from lemsynth.lemsynth_engine import solveProblem def notInChildren(x): return And(Not(IsMember(x, htree(lft(x)))), Not(IsMember(x, htree(rght(x))))) # declarations x, y = Vars('x y', fgsort) nil, ret = Consts('nil ret', fgsort) k = Const('k', intsort) key = Function('key', fgsort, intsort) lft = Function('lft', fgsort, fgsort) rght = Function('rght', fgsort, fgsort) dag = RecFunction('dag', fgsort, boolsort) tree = RecFunction('tree', fgsort, boolsort) htree = RecFunction('htree', fgsort, fgsetsort) AddRecDefinition(dag, x, If(x == nil, True, And(notInChildren(x), And(dag(lft(x)), dag(rght(x)))))) AddRecDefinition(tree, x, If(x == nil, True, And(notInChildren(x), And(SetIntersect(htree(lft(x)), htree(rght(x))) == fgsetsort.lattice_bottom, And(tree(lft(x)), tree(rght(x))))))) AddRecDefinition(htree, x, If(x == nil, fgsetsort.lattice_bottom, SetAdd(SetUnion(htree(lft(x)), htree(rght(x))), x))) AddAxiom((), lft(nil) == nil) AddAxiom((), rght(nil) == nil) # vc pgm = If(x == nil, ret == nil, ret == lft(x)) goal = Implies(tree(x), Implies(pgm, dag(ret))) # check validity with natural proof solver and no hardcoded lemmas
# declarations x, y = Vars('x y', fgsort) nil = Const('nil', fgsort) k = Const('k', intsort) nxt = Function('nxt', fgsort, fgsort) lst = RecFunction('lst', fgsort, boolsort) lseg = RecFunction('lseg', fgsort, fgsort, boolsort) key = Function('key', fgsort, intsort) keys = RecFunction('keys', fgsort, intsetsort) AddRecDefinition(lst, x, If(x == nil, True, lst(nxt(x)))) AddRecDefinition(lseg, (x, y) , If(x == y, True, lseg(nxt(x), y))) AddRecDefinition(keys, x, If(x == nil, fgsetsort.lattice_bottom, SetAdd(keys(nxt(x)), key(x)))) AddAxiom((), nxt(nil) == nil) # vc goal = Implies(lseg(x, y), Implies(And(And(And(x != nil, y != nil), lst(x)), key(y) == k), IsMember(k, keys(x)))) # check validity with natural proof solver and no hardcoded lemmas np_solver = NPSolver() solution = np_solver.solve(make_pfp_formula(goal)) if not solution.if_sat: print('goal (no lemmas) is valid') else: print('goal (no lemmas) is invalid') # hardcoded lemma lemma_params = (x,y) lemma_body = Implies(lseg(x, y), Implies(And(And(y != nil, lst(x)), key(y) == k), IsMember(k, keys(x)))) lemmas = {(lemma_params, lemma_body)} # check validity of lemmas
from naturalproofs.decl_api import Const, Consts, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.pfp import make_pfp_formula from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions # Declarations a, b, c, zero = Consts('a b c zero', fgsort) suc = Function('suc', fgsort, fgsort) pred = Function('pred', fgsort, fgsort) AddAxiom(a, pred(suc(a)) == a) nat = RecFunction('nat', fgsort, boolsort) add = RecFunction('add', fgsort, fgsort, fgsort, boolsort) AddRecDefinition(nat, a, If(a == zero, True, nat(pred(a)))) AddRecDefinition(add, (a, b, c), If(a == zero, b == c, add(pred(a), suc(b), c))) # Problem parameters goal = Implies(add(a, b, c), Implies(And(nat(a), nat(b)), nat(c))) pfp_of_goal = make_pfp_formula(goal) # Call a natural proofs solver npsolver = NPSolver() # Configure the solver npsolver.options.instantiation_mode = proveroptions.manual_instantiation npsolver.options.terms_to_instantiate = {a, b, c, zero, pred(b), suc(b)} # Ask for proof npsolution = npsolver.solve(pfp_of_goal) class AddIsNatTest(unittest.TestCase): def test1(self): self.assertFalse(npsolution.if_sat)
# Run from the Unix prompt '$' at the command line by issuing: # $ python3 pythagorean_triples.py # Run from the Python prompt '>>>' at the command line: # >>> execfile ('pythagorean_triples.py') # in Python2 only # >>> exec(open("./pythagorean_triples.py").read()) # in Python2 and Python3 from z3 import Solver, Ints, And, sat, Exists s = Solver() # Declare three integer variables/constants of Z3Py {x, y, z} : x, y, z = Ints('x y z') # Assert that {x, y, z} are positive integers such that 0 < x < y < z : s.add(And(0 < x, x < y, y < z, x >= 4, x % 2 == 0)) # Assert that x*x + y*y = z*z, i.e. (x,y,z) is a Pythagorean triple : s.add(x * x + y * y == z * z) s.add(x * x == 4 * y + 4) n = 1 results = [] while s.check() == sat and n <= 10: m = s.model() results.append(m) s.add(x != m[x]) n = n + 1 print(len(results), s.check())
from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from lemsynth.lemsynth_engine import solveProblem # Declarations x, y = Vars('x y', fgsort) nil = Const('nil', fgsort) nxt = Function('nxt', fgsort, fgsort) lseg = RecFunction('lseg', fgsort, fgsort, boolsort) cyclic = RecFunction('cyclic', fgsort, boolsort) AddRecDefinition(lseg, (x, y), If(x == y, True, If(x == nil, False, lseg(nxt(x), y)))) AddRecDefinition(cyclic, x, And(x != nil, lseg(nxt(x), x))) AddAxiom((), nxt(nil) == nil) # Problem parameters goal = Implies(cyclic(x), cyclic(nxt(x))) # parameters representing the grammar for synth-fun and # terms on which finite model is extracted # TODO: extract this automatically from grammar_string v1, v2 = Vars('v1 v2', fgsort) lemma_grammar_args = [v1, v2, nil] lemma_grammar_terms = {v1, v2, nxt(v1), nxt(v2), nil} name = 'cyclic-next' grammar_string = importlib_resources.read_text('experiments', 'grammar_{}.sy'.format(name))
def require(pre, b, post): return And(b.pre() >= pre, b.post() / pre <= post, +b)
x, y = Vars('x y', fgsort) nil, ret = Consts('nil ret', fgsort) k = Const('k', intsort) key = Function('key', fgsort, intsort) lft = Function('lft', fgsort, fgsort) rght = Function('rght', fgsort, fgsort) tree = RecFunction('tree', fgsort, boolsort) htree = RecFunction('htree', fgsort, fgsetsort) reach_lr = RecFunction('reach_lr', fgsort, fgsort, boolsort) AddRecDefinition( tree, x, If( x == nil, True, And( notInChildren(x), And( SetIntersect(htree(lft(x)), htree(rght(x))) == fgsetsort.lattice_bottom, And(tree(lft(x)), tree(rght(x))))))) AddRecDefinition( htree, x, If(x == nil, fgsetsort.lattice_bottom, SetAdd(SetUnion(htree(lft(x)), htree(rght(x))), x))) AddRecDefinition( reach_lr, (x, y), If(x == y, True, Or(reach_lr(lft(x), y), reach_lr(rght(x), y)))) AddAxiom((), lft(nil) == nil) AddAxiom((), rght(nil) == nil) # vc goal = Implies(reach_lr(x, y), Implies(And(key(x) != k, tree(x)), tree(y)))
CZGate._trivial_if = lambda self, x1: True CZGate._postconditions = lambda self, x1, y1: y1 == x1 # SGate SGate._trivial_if = lambda self, x1: True SGate._postconditions = lambda self, x1, y1: y1 == x1 SdgGate._trivial_if = lambda self, x1: True SdgGate._postconditions = lambda self, x1, y1: y1 == x1 # TGate TGate._trivial_if = lambda self, x1: True TGate._postconditions = lambda self, x1, y1: y1 == x1 TdgGate._trivial_if = lambda self, x1: True TdgGate._postconditions = lambda self, x1, y1: y1 == x1 # RzGate = U1Gate RZGate._trivial_if = lambda self, x1: True RZGate._postconditions = lambda self, x1, y1: y1 == x1 CRZGate._trivial_if = lambda self, x1: True CRZGate._postconditions = lambda self, x1, y1: y1 == x1 U1Gate._trivial_if = lambda self, x1: True U1Gate._postconditions = lambda self, x1, y1: y1 == x1 CU1Gate._trivial_if = lambda self, x1: True CU1Gate._postconditions = lambda self, x1, y1: y1 == x1 # MULTI-QUBIT GATES # # SwapGate SwapGate._trivial_if = lambda self, x1, x2: x1 == x2 SwapGate._postconditions = lambda self, x1, x2, y1, y2: And(x1 == y2, x2 == y1) CSwapGate._trivial_if = lambda self, x1, x2: x1 == x2 CSwapGate._postconditions = lambda self, x1, x2, y1, y2: And(x1 == y2, x2 == y1)
def has(self, x, y): return And(self.s1(x), self.s2(y))
x = Var('x', fgsort) c, s, nil = Consts('c s nil', fgsort) v1 = Function('v1', fgsort, fgsort) v2 = Function('v2', fgsort, fgsort) p = Function('p', fgsort, fgsort) n = Function('n', fgsort, fgsort) reach_pgm = RecFunction('reach_pgm', fgsort, boolsort) # precondition AddAxiom((), v1(s) == v2(s)) cond = v1(p(x)) != nil assign1 = v1(x) == n(v1(p(x))) assign2 = If(v2(p(x)) != c, v2(x) == n(v2(p(x))), v2(x) == v2(p(x))) assign = And(assign1, assign2) AddRecDefinition(reach_pgm, x, If(x == s, True, And(reach_pgm(p(x)), And(cond, assign)))) # vc lhs = v1(x) == nil rhs = Or(v2(x) == nil, v2(x) == c) goal = Implies(reach_pgm(x), Implies(lhs, rhs)) # check validity with natural proof solver and no hardcoded lemmas np_solver = NPSolver() solution = np_solver.solve(make_pfp_formula(goal)) if not solution.if_sat: print('goal (no lemmas) is valid') else: print('goal (no lemmas) is invalid')
def main(): """Status Park (Loop) solver example.""" for row in GIVENS: for cell in row: sys.stdout.write(cell) print() points = [] for y, row in enumerate(GIVENS): for x, c in enumerate(row): if c != X: points.append(Point(y, x)) lattice = RectangularLattice(points) sym = grilops.loops.LoopSymbolSet(lattice) sym.append("EMPTY", " ") sg = grilops.SymbolGrid(lattice, sym) lc = grilops.loops.LoopConstrainer(sg, single_loop=True) sc = grilops.shapes.ShapeConstrainer(lattice, [[Vector(y, x) for y, x in shape] for shape in SHAPES], solver=sg.solver, allow_rotations=True, allow_reflections=True, allow_copies=False) for p in points: if GIVENS[p.y][p.x] == W: # White circles must be part of the loop. sg.solver.add(lc.inside_outside_grid[p] == grilops.loops.L) elif GIVENS[p.y][p.x] == B: # Black circles must be part of a shape. sg.solver.add(sc.shape_type_grid[p] != -1) # A cell is part of the loop if and only if it is not part of # any shape. sg.solver.add((lc.inside_outside_grid[p] == grilops.loops.L) == ( sc.shape_type_grid[p] == -1)) # Orthogonally-adjacent cells must be part of the same shape. for n in sg.edge_sharing_neighbors(p): np = n.location sg.solver.add( Implies( And(sc.shape_type_grid[p] != -1, sc.shape_type_grid[np] != -1), sc.shape_type_grid[p] == sc.shape_type_grid[np])) if sg.solve(): sg.print() print() sc.print_shape_types() print() if sg.is_unique(): print("Unique solution") else: print("Alternate solution") sg.print() else: print("No solution")
minr(rght(x))))) AddRecDefinition( maxr, x, If(x == nil, -1, max_intsort(key(x), maxr(lft(x)), maxr(rght(x))))) AddRecDefinition( bst, x, If( x == nil, True, And( 0 < key(x), And( key(x) < 100, And( bst(lft(x)), And( bst(rght(x)), And( maxr(lft(x)) <= key(x), And( key(x) <= minr(rght(x)), And( notInChildren(x), SetIntersect(hbst(lft(x)), hbst(rght(x))) == fgsetsort.lattice_bottom))))))))) AddRecDefinition( hbst, x, If(x == nil, fgsetsort.lattice_bottom, SetAdd(SetUnion(hbst(lft(x)), hbst(rght(x))), x))) AddAxiom((), lft(nil) == nil) AddAxiom((), rght(nil) == nil) # vc
def all_commands_obeyed(state: EncodedState, commands: Iterable[Command]) -> BoolRef: logging.info('final state constraint') return And([commands_obeyed(state, c) for c in logging_tqdm(commands)])
def has(self, x, y): return And(self.r1(x, y), Not(self.r2(x, y)))
def notInChildren(x): return And(Not(IsMember(x, htree(lft(x)))), Not(IsMember(x, htree(rght(x)))))
def has(self, x, y): return And(self.r(x, y), self.s(y))
for mm in range(m): z3.add(pi[m][t] != pi[mm][t]) for l in range(L): z3.add(time[l] >= 0, time[l] < T) if l in G_1: z3.add(space[l] >= 0, space[l] < N) for t in range(T): z3.add(Implies(time[l] == t, pi[g[l]][t] == space[l])) elif l in G_2: z3.add(space[l] >= 0, space[l] < K) for k in range(K): for t in range(T): z3.add( Implies( And(time[l] == t, space[l] == k), Or( And(e[k][0] == pi[g[l][0]][t], e[k][1] == pi[g[l][1]][t]), And(e[k][1] == pi[g[l][0]][t], e[k][0] == pi[g[l][1]][t])))) for d in D: z3.add(time[d[0]] < time[d[1]]) """ # just for adder.qasm on ibmqx2 experiment compared with Wille et al., 2019 z3.add(time[3] <= time[8]) z3.add(time[8] <= time[9]) z3.add(time[9] <= time[10]) z3.add(time[10] <= time[11]) z3.add(time[11] <= time[12])
def has(self, x, y): a = const('a', get_sort_ran()) return Exists(a, And(self.r(x, a), self.s(a, y)))
def writeQDIMACS(filename, constraint, quantifiers, bitmap=None): # filename: String # constraints: list of BV constraints # quantifiers: list of tuples (['a','e','max','count'], list of vars) assert_consistent_quantifiers(quantifiers) log('Bit blasting') bitmap = {} for q in quantifiers: bitvecs = filter(is_bv, q[1]) localBitmap, localBitmapConstraints = create_bitmap(bitvecs) bitmap.update(localBitmap) constraint = And(localBitmapConstraints, constraint) newQuantifiedVars = filter(lambda v: not is_bv(v), q[1]) for (_, boolvar) in localBitmap.iteritems(): newQuantifiedVars.append(boolvar) q[1] = newQuantifiedVars g = Goal() g.add(constraint) matrix = [] t = Then('simplify', 'bit-blast', 'tseitin-cnf') subgoal = t(g) # print(subgoal[0][0].children()[1].children()[0] == bitmap()) assert len(subgoal) == 1 # print('Printing quantifier') # print(quantifiers) # print('Printing goal') # print(g) # exit() max_var = 0 var_mapping = {} # maps to qdimacs variables textFile = open(filename, "w") log('Creating and writing symbol table') textFile.write('c Symbol table for bitvectors\n') symbol_table = [] for ((bv, i), boolvar) in bitmap.iteritems(): max_var += 1 var_mapping[boolvar.get_id()] = max_var # symbol_table.append('c ' + str(boolvar) + ' --> ' + str(max_var)) textFile.write('c ' + str(boolvar) + ' --> ' + str(max_var) + '\n') log('Reserving variable names for quantified variables') for i, q in enumerate(quantifiers): for var in q[1]: if var.get_id() not in var_mapping: max_var += 1 var_mapping[var.get_id()] = max_var # minTseitin = max_var + 1 Tseitin_vars = [] log('Generating clauses ... (this may take a while)') clause_num = 0 for c in subgoal[0]: clause_num += 1 if clause_num % 10000 == 0: log(' {} clauses'.format(clause_num)) if is_or(c): clause = '' for l in c.children(): # literals max_var, lit_str = encode_literal(var_mapping, Tseitin_vars, max_var, l) clause += lit_str matrix.append(clause) elif is_const(c) or is_not(c): max_var, lit_str = encode_literal(var_mapping, Tseitin_vars, max_var, c) matrix.append(lit_str) else: log('Error: Unknown element ' + str(c)) assert false matrix.append('') log(' Generated ' + str(clause_num) + ' clauses') log('Writing header') textFile.write('p cnf {} {}\n'.format(max_var, clause_num)) # Extending quantifiers by innermost existential if necessary if quantifiers[-1][0] == 'a' and len( Tseitin_vars) > 0: # max_var + 1 - minTseitin > 0 quantifiers.append(['e', []]) # empty existential log('Writing quantifiers') for i, q in enumerate(quantifiers): textFile.write(q[0]) for v in q[1]: # try: v_id = v.get_id() textFile.write(' ' + str(var_mapping[v_id])) # except Exception as ex: # log(' Error when writing var {} to file ({})'.format(str(v), str(ex))) # # template = "An exception of type {0} occurred. Arguments:\n{1!r}" # message = template.format(type(ex).__name__, ex.args) # print message # # exit() if i == len(quantifiers) - 1: log('Adding {} Tseitin variables'.format(len(Tseitin_vars))) for varID in Tseitin_vars: textFile.write(' ' + str(varID)) # for varID in range(minTseitin,max_var+1): # # log('Adding var {}'.format(varID)) # textFile.write(' '+str(varID)) # # quantifiers[-1][1].append(varID) # log(' OK (added {} Tseitin vars)'.format(len(range(minTseitin,max_var+1)))) textFile.write(' 0\n') log('Writing clauses') textFile.write('0\n'.join(matrix)) textFile.close() return var_mapping
def has(self, y): x = const('x', get_sort_dom()) return Exists(x, And(self.r(x, y), self.s(x)))
# a is greater if (x > y): #throws: z3.z3types.Z3Exception: Symbolic expressions cannot be cast to concrete Boolean values. return GCD(x-y, y) return GCD(x, y-x) # def CoPrime(x, y): # return math.gcd(x, y) == 1 #x, y are 'ArithRef' not 'int' :< def CoPrime(x, y): return GCD(x, y) == 1 # Declare three integer variables/constants of Z3Py {x, y, z} : x, y, z, a, b = Ints ('x y z a b') # Assert that {x, y, z} are positive integers such that 0 < x < y < z : s.add (And( 0 < x , x < y , y < z ) ) # Assert that x*x + y*y = z*z, i.e. (x,y,z) is a Pythagorean triple : s.add ( x * x + y * y == z * z ) # x = a^2 - b^2, y = 2ab, z = a^2 + b^2 s.add(And(x == (a * a) - (b * b), y == 2 * a * b, z == (a * a) + (b * b))) # a>b>0 s.add(And(b > 0, a > b)) # a and b both not odd (idk why this works) s.add(Or(And(Odd(a), Not(Odd(b))), And(Odd(b), Not(Odd(a))))) s.add(Not(Odd(a) == Odd(b))) #ok apparently i needed both of these....? #a and b coprime (GCD of both numbers == 1)
def has(self, x): y = const('y', get_sort_ran()) return Exists(y, And(self.r(x, y), self.s(y)))
def not_(constraint: Union[BoolRef, _NamedUIDObject]) -> BoolRef: """Boolean negation of the constraint.""" return Not(And(_get_assertions(constraint)))
def havoc(s): p = prog(s, "havoc") x, y = elms("x y") s.add(ForAll([x, y], And(p.set(x), p.pre(x), p.post(x, y)))) return p