def search_rectangle(b1, e1, b2, e2, b3, e3, b4, e4): x1 = Real('x1') x2 = Real('x2') x3 = Real('x3') x4 = Real('x4') y1 = Real('y1') y2 = Real('y2') y3 = Real('y3') y4 = Real('y4') optimizer = Optimize() add_cond_on_segment(optimizer, b1, e1, x1, y1) add_cond_on_segment(optimizer, b2, e2, x2, y2) add_cond_on_segment(optimizer, b3, e3, x3, y3) add_cond_on_segment(optimizer, b4, e4, x4, y4) add_cond_orthogonal(optimizer, x1, y1, x2, y2, x3, y3) add_cond_orthogonal(optimizer, x2, y2, x3, y3, x4, y4) add_cond_orthogonal(optimizer, x3, y3, x4, y4, x1, y1) add_cond_orthogonal(optimizer, x4, y4, x1, y1, x2, y2) # equal_distance #optimizer.add_soft((x2-x1)**2+(y2-y1)**2==(x4-x3)**2+(y4-y3)**2) #optimizer.add_soft((x3-x2)**2+(y3-y2)**2==(x4-x1)**2+(y4-y1)**2) #optimizer.maximize(z3abs((x2-x1)*(y4-y1)-(x4-x1)*(y2-y1))) result = optimizer.check() print(result) fig = plt.figure() ax = fig.add_subplot(111) plotline(ax, b1, e1) plotline(ax, b2, e2) plotline(ax, b3, e3) plotline(ax, b4, e4) if result != z3.unsat: print(optimizer.model()) model = optimizer.model() x1 = convert_py_type(model[x1]) x2 = convert_py_type(model[x2]) x3 = convert_py_type(model[x3]) x4 = convert_py_type(model[x4]) y1 = convert_py_type(model[y1]) y2 = convert_py_type(model[y2]) y3 = convert_py_type(model[y3]) y4 = convert_py_type(model[y4]) plotline(ax, [x1, y1], [x2, y2], 'k') plotline(ax, [x2, y2], [x3, y3], 'k') plotline(ax, [x3, y3], [x4, y4], 'k') plotline(ax, [x4, y4], [x1, y1], 'k') else: print('no soltion') plt.gca().set_aspect('equal', adjustable='box') plt.show()
def search_rectangle(b1, e1, b2, e2, b3, e3, b4, e4): x1 = Real('x1') x2 = Real('x2') x3 = Real('x3') x4 = Real('x4') y1 = Real('y1') y2 = Real('y2') y3 = Real('y3') y4 = Real('y4') optimizer = Optimize() add_cond_on_segment(optimizer, b1, e1, x1, y1) add_cond_on_segment(optimizer, b2, e2, x2, y2) add_cond_on_segment(optimizer, b3, e3, x3, y3) add_cond_on_segment(optimizer, b4, e4, x4, y4) add_cond_orthogonal(optimizer, x1, y1, x2, y2, x3, y3) add_cond_orthogonal(optimizer, x2, y2, x3, y3, x4, y4) add_cond_orthogonal(optimizer, x3, y3, x4, y4, x1, y1) add_cond_orthogonal(optimizer, x4, y4, x1, y1, x2, y2) # equal_distance #optimizer.add_soft((x2-x1)**2+(y2-y1)**2==(x4-x3)**2+(y4-y3)**2) #optimizer.add_soft((x3-x2)**2+(y3-y2)**2==(x4-x1)**2+(y4-y1)**2) #optimizer.maximize(z3abs((x2-x1)*(y4-y1)-(x4-x1)*(y2-y1))) result = optimizer.check() print(result) fig = plt.figure() ax = fig.add_subplot(111) plotline(ax, b1, e1) plotline(ax, b2, e2) plotline(ax, b3, e3) plotline(ax, b4, e4) if result != z3.unsat: print(optimizer.model()) model = optimizer.model() x1 = convert_py_type(model[x1]) x2 = convert_py_type(model[x2]) x3 = convert_py_type(model[x3]) x4 = convert_py_type(model[x4]) y1 = convert_py_type(model[y1]) y2 = convert_py_type(model[y2]) y3 = convert_py_type(model[y3]) y4 = convert_py_type(model[y4]) plotline(ax, [x1, y1], [x2, y2], 'k') plotline(ax, [x2, y2], [x3, y3], 'k') plotline(ax, [x3, y3], [x4, y4], 'k') plotline(ax, [x4, y4], [x1, y1], 'k') else: print('no soltion') plt.gca().set_aspect('equal', adjustable='box') plt.show()
class Y2021D24(object): _re_inp = re.compile(r'inp ([wxyz])') _re_add = re.compile(r'add ([wxyz]) ([wxyz]|-?\d+)') _re_mul = re.compile(r'mul ([wxyz]) ([wxyz]|-?\d+)') _re_div = re.compile(r'div ([wxyz]) ([wxyz]|-?\d+)') _re_mod = re.compile(r'mod ([wxyz]) ([wxyz]|-?\d+)') _re_eql = re.compile(r'eql ([wxyz]) ([wxyz]|-?\d+)') def __init__(self, file_name): self.solver = Optimize() inputs = [Int(f'model_{i}') for i in range(14)] self.solver.add([i >= 1 for i in inputs]) self.solver.add([i <= 9 for i in inputs]) # Please don't ask me to explain this. There's a common pattern in the input code that treats z like a number # of base 26 and the operations are either right shift or left shift on that number +- some value. self.solver.add(inputs[0] + 6 - 6 == inputs[13]) self.solver.add(inputs[1] + 11 - 6 == inputs[12]) self.solver.add(inputs[2] + 5 - 13 == inputs[11]) self.solver.add(inputs[3] + 6 - 8 == inputs[8]) self.solver.add(inputs[4] + 8 - 1 == inputs[5]) self.solver.add(inputs[6] + 9 - 16 == inputs[7]) self.solver.add(inputs[9] + 13 - 16 == inputs[10]) my_sum = IntVal(0) for index in range(len(inputs)): my_sum = (my_sum * 10) + inputs[index] self.value = Int('value') self.solver.add(my_sum == self.value) def part1(self): self.solver.push() self.solver.maximize(self.value) self.solver.check() result = self.solver.model()[self.value] self.solver.pop() print("Part 1:", result) def part2(self): self.solver.push() self.solver.minimize(self.value) self.solver.check() result = self.solver.model()[self.value] self.solver.pop() print("Part 2:", result)
def geometry_free_solve_(ddn1, ddn2, ws, station_data, sta1, sta2, prn1, prn2, ticks): lambda_1 = lambda_1s[prn1[0]] lambda_2 = lambda_2s[prn1[0]] # Φ_i - R_i = B_i + err with B_i = b_i + λ_1*N_1 - λ_2*N_2 B_i = bias(tec.geometry_free) sol = Optimize() # sol = Solver() errs = Reals('err_11 err_12 err_21 err_22') n1s = Ints('n1_11 n1_12 n1_21 n1_22') n2s = Ints('n2_11 n2_12 n2_21 n2_22') sol.add(n1s[0] - n1s[1] - n1s[2] + n1s[3] == ddn1) sol.add(n2s[0] - n2s[1] - n2s[2] + n2s[3] == ddn2) for i, (sta, prn) in enumerate(product([sta1, sta2], [prn1, prn2])): sol.add(n1s[i] - n2s[i] == ws[i]) B_i_samples = [] for tick in ticks: B_i_samples.append( B_i(station_data[sta][prn][tick])[0] ) B_i_avg = numpy.mean(B_i_samples) # B_i_avg = B_i_samples[0] print(B_i_avg, numpy.std(B_i_samples)) sol.add(lambda_1 * ToReal(n1s[i]) - lambda_2 * ToReal(n2s[i]) + errs[i] > B_i_avg) sol.add(lambda_1 * ToReal(n1s[i]) - lambda_2 * ToReal(n2s[i]) - errs[i] < B_i_avg) """ sol.add(errs[0] < .9) sol.add(errs[1] < .9) sol.add(errs[2] < .9) sol.add(errs[3] < .9) """ #sol.add(errs[0] + errs[1] + errs[2] + errs[3] < 17) objective = sol.minimize(errs[0] + errs[1] + errs[2] + errs[3]) if sol.check() != sat: return None sol.lower(objective) if sol.check() != sat: return None # sol.add(errs[0] + errs[1] + errs[2] + errs[3] < 2) # can't do L2 norm with z3, L1 will have to do... # sol.(errs[0] + errs[1] + errs[2] + errs[3]) return ( [sol.model()[n1s[i]].as_long() for i in range(4)], [sol.model()[n2s[i]].as_long() for i in range(4)], [frac_to_float(sol.model()[errs[i]]) for i in range(4)], )
def main(args): data = [extract(s.strip()) for s in sys.stdin] data = [(x[3], tuple(x[:-1])) for x in data] m = max(data) in_range = [x for x in data if dist(x[1], m[1]) <= m[0]] print(len(in_range)) x = Int('x') y = Int('y') z = Int('z') orig = (x, y, z) cost = Int('cost') cost_expr = x * 0 for r, pos in data: cost_expr += If(z3_dist(orig, pos) <= r, 1, 0) opt = Optimize() print("let's go") opt.add(cost == cost_expr) opt.maximize(cost) # I didn't do this step in my initial #2 ranking solution but I # suppose you should. # z3 does them lexicographically by default. opt.minimize(z3_dist((0, 0, 0), (x, y, z))) opt.check() model = opt.model() # print(model) pos = (model[x].as_long(), model[y].as_long(), model[z].as_long()) print("position:", pos) print("num in range:", model[cost].as_long()) print("distance:", dist((0, 0, 0), pos))
def find_max(constraints, expr, l = None): if l is None: l = logger if type(expr) == int: return expr constraint_strs = [f'{c}' for c in constraints] max_optimize = Optimize() max_optimize.set('timeout', 10000) max_optimize.assert_exprs(*constraints) max_optimize.maximize(expr) status = max_optimize.check() if status != sat: l.warning(f'Unable to find max ({status}) for:\n' + '\n'.join(constraint_strs)) return None max_val = max_optimize.model().eval(expr).as_long() # Make sure it's actually the max, since z3 has a bug # https://github.com/Z3Prover/z3/issues/4670 solver = Solver() solver.set('timeout', 10000) solver.add(constraints + [expr > max_val]) status = solver.check() if status != unsat: l.error(f'Z3 bug\nFind max ({expr}) => {max_val} with status ({status}):\n' + '\n'.join(constraint_strs)) return None return max_val
def find_min(constraints, expr, default_min=0): if type(expr) == int: return expr constraint_strs = [f'{c}' for c in constraints] min_optimize = Optimize() min_optimize.set('timeout', 10000) min_optimize.assert_exprs(*constraints) min_optimize.minimize(expr) status = min_optimize.check() if status != sat: print(f'Unable to find min ({status}) for:\n' + '\n'.join(constraint_strs)) return None min_val = min_optimize.model().eval(expr).as_long() # Make sure it's actually the min, since z3 has a bug # https://github.com/Z3Prover/z3/issues/4670 solver = Solver() solver.set('timeout', 10000) solver.add(constraints + [expr < min_val]) status = solver.check() if status != unsat: print( f'Z3 bug\nFind min ({expr}) => {min_val} with status ({status}):\n' + '\n'.join(constraint_strs)) return None return min_val
def main(): bots = [] with open("input.txt") as f: for line in f: bots.append(tuple(map(int, re.findall(r"-?\d+", line)))) x, y, z, r = max(bots, key=lambda b: b[3]) in_range = sum( (abs(x - b[0]) + abs(y - b[1]) + abs(z - b[2]) <= r) for b in bots) print("Part 1:", in_range) x, y, z = Int("x"), Int("y"), Int("z") point = (x, y, z) count = sum(If(z3_dist(b[:3], point) <= b[3], 1, 0) for b in bots) opt = Optimize() opt.maximize(count) opt.minimize(z3_dist(point, (0, 0, 0))) opt.check() model = opt.model() result = model[x].as_long() + model[y].as_long() + model[z].as_long() print("Part 2:", result)
def test(qcirc): #print(qcirc) print("Translate to Z3") circ = QuantumCircuit_to_Circuit(qcirc, melbourne_rels, positions) # Collect Constraints print("Create Constraint Generator") cons = circ.constraints() # New Optimizer s = Optimize() # Add constraints print("Add All constraints") for con in cons: s.add(con) #print(con) # Add reliability objective print("Add Objective") s.maximize(reliability_objective(circ)) # Check and print print("Checking") sat = str(s.check()) print(sat) if sat == "unsat": raise Exception("unsat") print("Extracting Model") m = s.model() # Confirm that an improvement in reliability was made print("Reliability Checking") improved_reliability(m, s, melbourne_rels, qcirc) # Translate to qiskit QuantumCircuit print("Translate to Qiskit") rcirc = model_to_QuantumCircuit(m, circ)
def get_model(constraints, minimize=(), maximize=()): s = Optimize() s.set("timeout", 100000) for constraint in constraints: if type(constraint) == bool and not constraint: raise UnsatError constraints = [ constraint for constraint in constraints if type(constraint) != bool ] for constraint in constraints: s.add(constraint) for e in minimize: s.minimize(e) for e in maximize: s.maximize(e) result = s.check() if result == sat: return s.model() elif result == unknown: logging.debug("Timeout encountered while solving expression using z3") raise UnsatError
def dd_solve_(dd, vr1s1, vr1s2, vr2s1, vr2s2, wavelength, ionosphere=False): sol = Optimize() r1s1, r1s2, r2s1, r2s2 = Ints('r1s1 r1s2 r2s1 r2s2') # err = Real('err') err1, err2, err3, err4 = Reals('err1 err2 err3 err4') # sol.add(err > 0) if ionosphere: ion = Real('ion') sol.add(ion > 0) sol.add(ion < 25) else: ion = 0 sol.add(r1s1 - r1s2 - r2s1 + r2s2 == dd) sol.add(ToReal(r1s1)*wavelength + err1 > vr1s1 - ion) sol.add(ToReal(r1s1)*wavelength - err1 < vr1s1 - ion) sol.add(ToReal(r1s2)*wavelength + err2 > vr1s2 - ion) sol.add(ToReal(r1s2)*wavelength - err2 < vr1s2 - ion) sol.add(ToReal(r2s1)*wavelength + err3 > vr2s1 - ion) sol.add(ToReal(r2s1)*wavelength - err3 < vr2s1 - ion) sol.add(ToReal(r2s2)*wavelength + err4 > vr2s2 - ion) sol.add(ToReal(r2s2)*wavelength - err4 < vr2s2 - ion) objective = sol.minimize(err1 + err2 + err3 + err4) if sol.check() != sat: return None sol.lower(objective) if sol.check() != sat: return None return ( [sol.model()[r].as_long() for r in [r1s1, r1s2, r2s1, r2s2]], [frac_to_float(sol.model()[err]) for err in [err1, err2, err3, err4]], frac_to_float(sol.model()[ion]) if ionosphere else 0 )
def optimum_dist(bots): x = Int('x') y = Int('y') z = Int('z') cost_expr = x * 0 for i, j, k, r in bots: cost_expr += If(z3_dist((x, y, z), (i, j, k)) <= r, 1, 0) opt = Optimize() opt.maximize(cost_expr) opt.minimize(z3_dist((0, 0, 0), (x, y, z))) opt.check() model = opt.model() coords = (model[x].as_long(), model[y].as_long(), model[z].as_long()) return dist((0, 0, 0), coords)
def solve_boolean_formula_with_z3_smt2(self, bf): """Find minimum satisfying assignemnt for the boolean formula. # Example: # >>> bf = '(and (or a b) (not (and a c)))' # >>> appeared_symbol_list = ['a', 'b', 'c'] # >>> solve_boolean_formula_with_z3_smt2(bf, appeared_symbol_list) # ([b = True, a = False, c = False, s = 1], 1) """ appeared_symbol_list = list( set([ a if "not " not in a else a[5:-1] for a in self.prov_notations.values() ])) declaration_str = '\n'.join( list( map(lambda x: '(declare-const {} Bool)'.format(x), appeared_symbol_list))) declaration_str += '\n(declare-const s Int)' declaration_str += '\n(define-fun b2i ((x Bool)) Int (ite x 1 0))' size_str = '(+ {})'.format(' '.join( list(map(lambda x: '(b2i {})'.format(x), appeared_symbol_list)))) assert_str = '(assert {})\n'.format(bf) assert_str += '(assert (= s {}))\n(assert (>= s 0))'.format( size_str) # changed from (> s 0) z3_bf = parse_smt2_string(declaration_str + '\n' + assert_str) opt = Optimize() opt.add(z3_bf) s = Int('s') opt.minimize(s) # changed from opt.minimize(s) if opt.check() == sat: best_model = opt.model() min_size = 0 for cl in best_model: if isinstance(best_model[cl], BoolRef) and best_model[cl]: min_size += 1 return best_model, min_size else: return None, -1
def solve_pkgver_z3(pkg_dict, constrain_version_dict, optim_target="approximate"): # solver = Solver() solver = Optimize() int_dict = build_int_dict(pkg_dict) order_dict = build_order_dict(pkg_dict) solver = add_dependency_constrains(solver, pkg_dict, order_dict, int_dict) solver = add_int_constrains(solver, pkg_dict, int_dict) solver = add_version_constrains(solver, constrain_version_dict, order_dict, int_dict) if optim_target == "approximate": solver = add_optimize_targets(solver, int_dict) if optim_target == "exact": solver = add_optimize_targets2(solver, int_dict, order_dict) solver.set(timeout=60000) try: if solver.check(): pkgvers = parse_z3_model(solver.model(), int_dict, order_dict) return pkgvers else: return None except: return None
def _solve( solver: z3.Optimize, channels: List[Channel], devices: List[Device] ) -> Tuple[Problem, z3.Model]: problem = _problem(solver, freqs=[c.frequency for c in channels], devices=devices) if solver.check() != z3.sat: # TODO: consider getting an unsat core raise ValueError(f"No valid assignment possible, add more devices") # find the minimal number of devices that cover all frequencies # it is faster to do this iteratively than to offload these to # smt constraints. do this in reverse so we end up assigning # the lowest numbered devices for r in problem.ranges[::-1]: # to control the device placements adjust the order they're eliminated from # the solution. for example, this will prefer devices that have a smaller # minimum sample rate over devices with a larger one: # for r, _ in zip(problem.ranges, problem.devices), key=lambda x: -x[1].min_sample_rate solver.push() solver.add(r == 0) if solver.check() != z3.sat: solver.pop() break devices_required = z3.Sum([z3.If(r > 0, 1, 0) for r in problem.ranges]) # minimize the sum of frequency ranges solver.minimize(z3.Sum(*problem.ranges)) # and the frequency, just to produce deterministic results solver.minimize(z3.Sum(*problem.lower_freq)) assert solver.check() == z3.sat model = solver.model() print(f"Devices required: {model.eval(devices_required)}", file=sys.stderr) return problem, model
def run_inference(file_name=None, base_folder=None): if not file_name: if len(sys.argv) >= 2 and sys.argv[1] != '--help': file_name = sys.argv[1] if len(sys.argv) >= 3: base_folder = sys.argv[2] else: print_help() return start_time = time.time() class_type_params, func_type_params = configure_inference([flag for flag in sys.argv[2:] if flag.startswith("--")]) if not base_folder: base_folder = '' if file_name.endswith('.py'): file_name = file_name[:-3] t = ImportHandler.get_module_ast(file_name, base_folder) solver = z3_types.TypesSolver(t, base_folder=base_folder, type_params=func_type_params, class_type_params=class_type_params) context = Context(t, t.body, solver) context.type_params = solver.config.type_params context.class_type_params = solver.config.class_type_params solver.infer_stubs(context, infer) for stmt in t.body: infer(stmt, context, solver) solver.push() end_time = time.time() print("Constraints collection took {}s".format(end_time - start_time)) start_time = time.time() if config.config['enable_soft_constraints']: check = solver.optimize.check() else: check = solver.check(solver.assertions_vars) end_time = time.time() print("Constraints solving took {}s".format(end_time - start_time)) write_path = "inference_output/" + base_folder if not os.path.exists(write_path): os.makedirs(write_path) if write_path.endswith('/'): write_path = write_path[:-1] file = open(write_path + '/{}_constraints_log.txt'.format(file_name.replace('/', '.')), 'w') file.write(print_solver(solver)) file.close() if check == z3_types.unsat: print("Check: unsat") if config.config["print_unsat_core"]: print("Writing unsat core to {}".format(write_path)) if config.config['enable_soft_constraints']: solver.check(solver.assertions_vars) core = solver.unsat_core() else: core = solver.unsat_core() core_string = '\n'.join(solver.assertions_errors[c] for c in core) file = open(write_path + '/{}_unsat_core.txt'.format(file_name), 'w') file.write(core_string) file.close() model = None opt = Optimize(solver.ctx) for av in solver.assertions_vars: opt.add_soft(av) for a in solver.all_assertions: opt.add(a) for a in solver.z3_types.subtyping: opt.add(a) for a in solver.z3_types.subst_axioms: opt.add(a) for a in solver.forced: opt.add(a) start_time = time.time() opt.check() model = opt.model() end_time = time.time() print("Solving relaxed model took {}s".format(end_time - start_time)) for av in solver.assertions_vars: if not model[av]: print("Unsat:") print(solver.assertions_errors[av]) else: opt = Optimize(solver.ctx) for av in solver.assertions_vars: opt.add_soft(av) for a in solver.all_assertions: opt.add(a) for a in solver.z3_types.subtyping: opt.add(a) for a in solver.z3_types.subst_axioms: opt.add(a) for a in solver.forced: opt.add(a) start_time = time.time() opt.check() model = opt.model() end_time = time.time() print("Solving relaxed model took {}s".format(end_time - start_time)) for av in solver.assertions_vars: if not model[av]: print("Unsat:") print(solver.assertions_errors[av]) else: if config.config['enable_soft_constraints']: model = solver.optimize.model() else: model = solver.model() if model is not None: print("Writing output to {}".format(write_path)) context.generate_typed_ast(model, solver) ImportHandler.add_required_imports(file_name, t, context) write_path += '/' + file_name + '.py' if not os.path.exists(os.path.dirname(write_path)): os.makedirs(os.path.dirname(write_path)) file = open(write_path, 'w') file.write(astunparse.unparse(t)) file.close() ImportHandler.write_to_files(model, solver)
# Clauses s = Optimize() s.add(at_least_one_bomb_for_each_rectangle(2, 3)) s.add(at_least_one_bomb_for_each_rectangle(3, 2)) # Objective num_bombs = Sum([If(is_bomb[r][c], 1, 0) for (r, c) in rectangle(H, W)]) min_bombs = s.minimize(num_bombs) if s.check() == sat: assert s.lower(min_bombs) == 6 print("The minimum number of bombs satisfying the constraints == %s." % s.lower(min_bombs)) print(diagram(s.model())) else: print("Z3 failed to find a solution.") # http://forum.stratego.com/topic/1134-stratego-quizz-and-training-forum/?p=11661 # http://forum.stratego.com/topic/1146-stratego-quizz-and-training-forum-answers/?p=11813 # http://forum.stratego.com/topic/1134-stratego-quizz-and-training-forum/?p=441745 print( "The minimum number of bombs on a Stratego setup area such that each 2x3, 3x2 and 1x6 rectangle has at least one bomb." ) # Extra clause s.add(at_least_one_bomb_for_each_rectangle(1, 6)) if s.check() == sat: assert s.lower(min_bombs) == 7
def solve(self, output_mode: str = None, output_file_name: str = None): """Formulate an SMT, pass it to z3 solver, and output results. CORE OF OLSQ, EDIT WITH CARE. Args: output_mode: "IR" or left to default. output_file_name: a file to store the IR output or qasm. Returns: a list of results depending on output_mode "IR": | list_scheduled_gate_name: name/type of each gate | list_scheduled_gate_qubits: qubit(s) each gate acts on | final_mapping: logical qubit |-> physical qubit in the end | objective_value: depth/#swap/fidelity depending on setting None: a qasm string final_mapping objective_value """ objective_name = self.objective_name device = self.device list_gate_qubits = self.list_gate_qubits count_program_qubit = self.count_program_qubit list_gate_name = self.list_gate_name count_physical_qubit = self.count_physical_qubit list_qubit_edge = self.list_qubit_edge swap_duration = self.swap_duration bound_depth = self.bound_depth # pre-processing count_qubit_edge = len(list_qubit_edge) count_gate = len(list_gate_qubits) if self.objective_name == "fidelity": list_logfidelity_single = [ int(1000 * math.log(device.list_fidelity_single[n])) for n in range(count_physical_qubit)] list_logfidelity_two = [ int(1000 * math.log(device.list_fidelity_two[k])) for k in range(count_qubit_edge)] list_logfidelity_measure = [ int(1000 * math.log(device.list_fidelity_measure[n])) for n in range(count_physical_qubit)] list_gate_two = list() list_gate_single = list() for l in range(count_gate): if len(list_gate_qubits[l]) == 1: list_gate_single.append(l) else: list_gate_two.append(l) # list_adjacency_qubit takes in a physical qubit index _p_, and # returns the list of indices of physical qubits adjacent to _p_ list_adjacent_qubit = list() # list_span_edge takes in a physical qubit index _p_, # and returns the list of edges spanned from _p_ list_span_edge = list() for n in range(count_physical_qubit): list_adjacent_qubit.append(list()) list_span_edge.append(list()) for k in range(count_qubit_edge): list_adjacent_qubit[list_qubit_edge[k][0]].append( list_qubit_edge[k][1]) list_adjacent_qubit[list_qubit_edge[k][1]].append( list_qubit_edge[k][0]) list_span_edge[list_qubit_edge[k][0]].append(k) list_span_edge[list_qubit_edge[k][1]].append(k) # if_overlap_edge takes in two edge indices _e_ and _e'_, # and returns whether or not they overlap if_overlap_edge = [[0] * count_qubit_edge for k in range(count_qubit_edge)] # list_over_lap_edge takes in an edge index _e_, # and returnsthe list of edges that overlap with _e_ list_overlap_edge = list() # list_count_overlap_edge is the list of lengths of # overlap edge lists of all the _e_ list_count_overlap_edge = list() for k in range(count_qubit_edge): list_overlap_edge.append(list()) for k in range(count_qubit_edge): for kk in range(k + 1, count_qubit_edge): if ( (list_qubit_edge[k][0] == list_qubit_edge[kk][0] or list_qubit_edge[k][0] == list_qubit_edge[kk][1]) or (list_qubit_edge[k][1] == list_qubit_edge[kk][0] or list_qubit_edge[k][1] == list_qubit_edge[kk][1]) ): list_overlap_edge[k].append(kk) list_overlap_edge[kk].append(k) if_overlap_edge[kk][k] = 1 if_overlap_edge[k][kk] = 1 for k in range(count_qubit_edge): list_count_overlap_edge.append(len(list_overlap_edge[k])) if not self.inpput_dependency: list_gate_dependency = collision_extracting(list_gate_qubits) else: list_gate_dependency = self.list_gate_dependency # index function: takes two physical qubit indices _p_ and _p'_, # and returns the index of the edge between them if there is one map_edge_index = [[0] * count_physical_qubit] * count_physical_qubit for k in range(count_qubit_edge): map_edge_index[list_qubit_edge[k][0]][list_qubit_edge[k][1]] = k map_edge_index[list_qubit_edge[k][1]][list_qubit_edge[k][0]] = k not_solved = True start_time = datetime.datetime.now() while not_solved: print("Trying maximal depth = {}...".format(bound_depth)) # variable setting # at cycle t, logical qubit q is mapped to pi[q][t] pi = [[Int("map_q{}_t{}".format(i, j)) for j in range(bound_depth)] for i in range(count_program_qubit)] # time coordinate for gate l is time[l] time = IntVector('time', count_gate) # space coordinate for gate l is space[l] space = IntVector('space', count_gate) # if at cycle t, a SWAP finishing on edge k, then sigma[k][t]=1 sigma = [[Bool("ifswap_e{}_t{}".format(i, j)) for j in range(bound_depth)] for i in range(count_qubit_edge)] # for depth optimization depth = Int('depth') # for swap optimization count_swap = Int('num_swap') # for fidelity optimization if objective_name == "fidelity": u = [Int("num_1qbg_p{}".format(n)) for n in range(count_physical_qubit)] v = [Int("num_2qbg_e{}".format(k)) for k in range(count_qubit_edge)] vv = [Int("num_swap_e{}".format(k)) for k in range(count_qubit_edge)] w = [Int("num_meas_p{}".format(n)) for n in range(count_physical_qubit)] fidelity = Int('log_fidelity') lsqc = Optimize() # constraint setting for t in range(bound_depth): for m in range(count_program_qubit): lsqc.add(pi[m][t] >= 0, pi[m][t] < count_physical_qubit) for mm in range(m): lsqc.add(pi[m][t] != pi[mm][t]) for l in range(count_gate): lsqc.add(time[l] >= 0, time[l] < bound_depth) if l in list_gate_single: lsqc.add(space[l] >= 0, space[l] < count_physical_qubit) for t in range(bound_depth): lsqc.add(Implies(time[l] == t, pi[list_gate_qubits[l][0]][t] == space[l])) elif l in list_gate_two: lsqc.add(space[l] >= 0, space[l] < count_qubit_edge) for k in range(count_qubit_edge): for t in range(bound_depth): lsqc.add(Implies(And(time[l] == t, space[l] == k), Or(And(list_qubit_edge[k][0] == \ pi[list_gate_qubits[l][0]][t], list_qubit_edge[k][1] == \ pi[list_gate_qubits[l][1]][t]), And(list_qubit_edge[k][1] == \ pi[list_gate_qubits[l][0]][t], list_qubit_edge[k][0] == \ pi[list_gate_qubits[l][1]][t]) ) )) for d in list_gate_dependency: if self.if_transition_based: lsqc.add(time[d[0]] <= time[d[1]]) else: lsqc.add(time[d[0]] < time[d[1]]) for t in range(min(swap_duration - 1, bound_depth)): for k in range(count_qubit_edge): lsqc.add(sigma[k][t] == False) for t in range(swap_duration - 1, bound_depth): for k in range(count_qubit_edge): for tt in range(t - swap_duration + 1, t): lsqc.add(Implies(sigma[k][t] == True, sigma[k][tt] == False)) for tt in range(t - swap_duration + 1, t + 1): for kk in list_overlap_edge[k]: lsqc.add(Implies(sigma[k][t] == True, sigma[kk][tt] == False)) if not self.if_transition_based: for t in range(swap_duration - 1, bound_depth): for k in range(count_qubit_edge): for tt in range(t - swap_duration + 1, t + 1): for l in range(count_gate): if l in list_gate_single: lsqc.add(Implies(And(time[l] == tt, Or(space[l] == list_qubit_edge[k][0], space[l] == list_qubit_edge[k][1])), sigma[k][t] == False )) elif l in list_gate_two: lsqc.add(Implies(And( time[l] == tt, space[l] == k), sigma[k][t] == False )) for kk in list_overlap_edge[k]: lsqc.add(Implies(And( time[l] == tt, space[l] == kk), sigma[k][t] == False )) for t in range(bound_depth - 1): for n in range(count_physical_qubit): for m in range(count_program_qubit): lsqc.add( Implies(And(sum([If(sigma[k][t], 1, 0) for k in list_span_edge[n]]) == 0, pi[m][t] == n), pi[m][t + 1] == n)) for t in range(bound_depth - 1): for k in range(count_qubit_edge): for m in range(count_program_qubit): lsqc.add(Implies(And(sigma[k][t] == True, pi[m][t] == list_qubit_edge[k][0]), pi[m][t + 1] == list_qubit_edge[k][1])) lsqc.add(Implies(And(sigma[k][t] == True, pi[m][t] == list_qubit_edge[k][1]), pi[m][t + 1] == list_qubit_edge[k][0])) lsqc.add( count_swap == sum([If(sigma[k][t], 1, 0) for k in range(count_qubit_edge) for t in range(bound_depth)])) # for depth optimization for l in range(count_gate): lsqc.add(depth >= time[l] + 1) if objective_name == "swap": lsqc.minimize(count_swap) elif objective_name == "depth": lsqc.minimize(depth) elif objective_name == "fidelity": for n in range(count_physical_qubit): lsqc.add(u[n] == sum([If(space[l] == n, 1, 0) for l in list_gate_single])) lsqc.add(w[n] == sum([If(pi[m][bound_depth - 1] == n, 1, 0) for m in range(count_program_qubit)])) for k in range(count_qubit_edge): lsqc.add(v[k] == sum([If(space[l] == k, 1, 0) for l in list_gate_two])) lsqc.add(vv[k] == sum([If(sigma[k][t], 1, 0) for t in range(bound_depth)])) lsqc.add(fidelity == sum([v[k] * list_logfidelity_two[k] for k in range(count_qubit_edge)]) + sum([ swap_duration * vv[k] * list_logfidelity_two[k] for k in range(count_qubit_edge)]) + sum([w[n] * list_logfidelity_measure[n] for n in range(count_physical_qubit)]) + sum([u[n] * list_logfidelity_single[n] for n in range(count_physical_qubit)]) ) lsqc.maximize(fidelity) else: raise Exception("Invalid Objective Name") satisfiable = lsqc.check() if satisfiable == sat: not_solved = False else: if self.if_transition_based: bound_depth += 1 else: bound_depth = int(1.3 * bound_depth) print(f"Compilation time = {datetime.datetime.now() - start_time}.") model = lsqc.model() # post-processing result_time = [] result_depth = model[depth].as_long() for l in range(count_gate): result_time.append(model[time[l]].as_long()) list_result_swap = [] for k in range(count_qubit_edge): for t in range(result_depth): if model[sigma[k][t]]: list_result_swap.append((k, t)) print(f"SWAP on physical edge ({list_qubit_edge[k][0]},"\ + f"{list_qubit_edge[k][1]}) at time {t}") for l in range(count_gate): if len(list_gate_qubits[l]) == 1: qq = list_gate_qubits[l][0] tt = result_time[l] print(f"Gate {l}: {list_gate_name[l]} {qq} on qubit "\ + f"{model[pi[qq][tt]].as_long()} at time {tt}") else: qq = list_gate_qubits[l][0] qqq = list_gate_qubits[l][1] tt = result_time[l] print(f"Gate {l}: {list_gate_name[l]} {qq}, {qqq} on qubits "\ + f"{model[pi[qq][tt]].as_long()} and "\ + f"{model[pi[qqq][tt]].as_long()} at time {tt}") # transition based if self.if_transition_based: self.swap_duration = self.device.swap_duration map_to_block = dict() real_time = [0 for i in range(count_gate)] list_depth_on_qubit = [-1 for i in range(self.count_physical_qubit)] list_real_swap = [] for block in range(result_depth): for tmp_gate in range(count_gate): if result_time[tmp_gate] == block: qubits = list_gate_qubits[tmp_gate] if len(qubits) == 1: p0 = model[pi[qubits[0]][block]].as_long() real_time[tmp_gate] = \ list_depth_on_qubit[p0] + 1 list_depth_on_qubit[p0] = \ real_time[tmp_gate] map_to_block[real_time[tmp_gate]] = block else: p0 = model[pi[qubits[0]][block]].as_long() p1 = model[pi[qubits[1]][block]].as_long() real_time[tmp_gate] = max( list_depth_on_qubit[p0], list_depth_on_qubit[p1]) + 1 list_depth_on_qubit[p0] = \ real_time[tmp_gate] list_depth_on_qubit[p1] = \ real_time[tmp_gate] map_to_block[real_time[tmp_gate]] = block # print(f"{tmp_gate} {p0} {p1} real-time={real_time[tmp_gate]}") if block < result_depth - 1: for (k, t) in list_result_swap: if t == block: p0 = list_qubit_edge[k][0] p1 = list_qubit_edge[k][1] tmp_time = max(list_depth_on_qubit[p0], list_depth_on_qubit[p1]) \ + self.swap_duration list_depth_on_qubit[p0] = tmp_time list_depth_on_qubit[p1] = tmp_time list_real_swap.append((k, tmp_time)) # print(list_depth_on_qubit) result_time = real_time real_depth = 0 for tmp_depth in list_depth_on_qubit: if real_depth < tmp_depth + 1: real_depth = tmp_depth + 1 result_depth = real_depth list_result_swap = list_real_swap # print(list_result_swap) objective_value = 0 if objective_name == "fidelity": objective_value = model[fidelity].as_long() print(f"result fidelity = {math.exp(objective_value / 1000.0)}") elif objective_name == "swap": objective_value = len(list_result_swap) print(f"result additional SWAP count = {objective_value}.") else: objective_value = model[depth].as_long() print(f"result circuit depth = {objective_value}.") list_scheduled_gate_qubits = [[] for i in range(result_depth)] list_scheduled_gate_name = [[] for i in range(result_depth)] result_depth = 0 for l in range(count_gate): t = result_time[l] if result_depth < t + 1: result_depth = t + 1 list_scheduled_gate_name[t].append(list_gate_name[l]) if l in list_gate_single: q = model[space[l]].as_long() list_scheduled_gate_qubits[t].append((q,)) elif l in list_gate_two: [q0, q1] = list_gate_qubits[l] tmp_t = t if self.if_transition_based: tmp_t = map_to_block[t] q0 = model[pi[q0][tmp_t]].as_long() q1 = model[pi[q1][tmp_t]].as_long() list_scheduled_gate_qubits[t].append((q0, q1)) else: raise ValueError("Expect single-qubit or two-qubit gate.") final_mapping = [] for m in range(count_program_qubit): tmp_depth = result_depth - 1 if self.if_transition_based: tmp_depth = map_to_block[result_depth - 1] final_mapping.append(model[pi[m][tmp_depth]].as_long()) for (k, t) in list_result_swap: q0 = list_qubit_edge[k][0] q1 = list_qubit_edge[k][1] if self.swap_duration == 1: list_scheduled_gate_qubits[t].append((q0, q1)) list_scheduled_gate_name[t].append("SWAP") elif self.swap_duration == 3: list_scheduled_gate_qubits[t].append((q0, q1)) list_scheduled_gate_name[t].append("cx") list_scheduled_gate_qubits[t - 1].append((q1, q0)) list_scheduled_gate_name[t - 1].append("cx") list_scheduled_gate_qubits[t - 2].append((q0, q1)) list_scheduled_gate_name[t - 2].append("cx") else: raise ValueError("Expect SWAP duration one, or three") if output_mode == "IR": if output_file_name: output_file = open(output_file_name, 'w') output_file.writelines([list_scheduled_gate_name, list_scheduled_gate_qubits, final_mapping, objective_value]) return (result_depth, list_scheduled_gate_name, list_scheduled_gate_qubits, final_mapping, objective_value) else: return (output_qasm(device, result_depth, list_scheduled_gate_name, list_scheduled_gate_qubits, final_mapping, True, output_file_name), final_mapping, objective_value)
class CrosstalkAdaptiveSchedule(TransformationPass): """Crosstalk mitigation through adaptive instruction scheduling.""" def __init__(self, backend_prop, crosstalk_prop, weight_factor=0.5, measured_qubits=None): """CrosstalkAdaptiveSchedule initializer. Args: backend_prop (BackendProperties): backend properties object crosstalk_prop (dict): crosstalk properties object crosstalk_prop[g1][g2] specifies the conditional error rate of g1 when g1 and g2 are executed simultaneously. g1 should be a two-qubit tuple of the form (x,y) where x and y are physical qubit ids. g2 can be either two-qubit tuple (x,y) or single-qubit tuple (x). We currently ignore crosstalk between pairs of single-qubit gates. Gate pairs which are not specified are assumed to be crosstalk free. Example:: crosstalk_prop = {(0, 1) : {(2, 3) : 0.2, (2) : 0.15}, (4, 5) : {(2, 3) : 0.1}, (2, 3) : {(0, 1) : 0.05, (4, 5): 0.05}} The keys of the crosstalk_prop are tuples for ordered tuples for CX gates e.g., (0, 1) corresponding to CX 0, 1 in the hardware. Each key has an associated value dict which specifies the conditional error rates with nearby gates e.g., ``(0, 1) : {(2, 3) : 0.2, (2) : 0.15}`` means that CNOT 0, 1 has an error rate of 0.2 when it is executed in parallel with CNOT 2,3 and an error rate of 0.15 when it is executed in parallel with a single qubit gate on qubit 2. weight_factor (float): weight of gate error/crosstalk terms in the objective :math:`weight_factor*fidelities + (1-weight_factor)*decoherence errors`. Weight can be varied from 0 to 1, with 0 meaning that only decoherence errors are optimized and 1 meaning that only crosstalk errors are optimized. weight_factor should be tuned per application to get the best results. measured_qubits (list): a list of qubits that will be measured in a particular circuit. This arg need not be specified for circuits which already include measure gates. The arg is useful when a subsequent module such as state_tomography_circuits inserts the measure gates. If CrosstalkAdaptiveSchedule is made aware of those measurements, it is included in the optimization. Raises: ImportError: if unable to import z3 solver """ super().__init__() self.backend_prop = backend_prop self.crosstalk_prop = crosstalk_prop self.weight_factor = weight_factor if measured_qubits is None: self.input_measured_qubits = [] else: self.input_measured_qubits = measured_qubits self.bp_u1_err = {} self.bp_u1_dur = {} self.bp_u2_err = {} self.bp_u2_dur = {} self.bp_u3_err = {} self.bp_u3_dur = {} self.bp_cx_err = {} self.bp_cx_dur = {} self.bp_t1_time = {} self.bp_t2_time = {} self.gate_id = {} self.gate_start_time = {} self.gate_duration = {} self.gate_fidelity = {} self.overlap_amounts = {} self.overlap_indicator = {} self.qubit_lifetime = {} self.dag_overlap_set = {} self.xtalk_overlap_set = {} self.opt = Optimize() self.measured_qubits = [] self.measure_start = None self.last_gate_on_qubit = None self.first_gate_on_qubit = None self.fidelity_terms = [] self.coherence_terms = [] self.model = None self.dag = None self.parse_backend_properties() def powerset(self, iterable): """ Finds the set of all subsets of the given iterable This function is used to generate constraints for the Z3 optimization """ l_s = list(iterable) return chain.from_iterable( combinations(l_s, r) for r in range(len(l_s) + 1)) def parse_backend_properties(self): """ This function assumes that gate durations and coherence times are in seconds in backend.properties() This function converts gate durations and coherence times to nanoseconds. """ backend_prop = self.backend_prop for qid in range(len(backend_prop.qubits)): self.bp_t1_time[qid] = int(backend_prop.t1(qid) * 10**9) self.bp_t2_time[qid] = int(backend_prop.t2(qid) * 10**9) self.bp_u1_dur[qid] = int(backend_prop.gate_length('u1', qid)) * 10**9 u1_err = backend_prop.gate_error('u1', qid) if u1_err == 1.0: u1_err = 0.9999 self.bp_u1_err = round(u1_err, NUM_PREC) self.bp_u2_dur[qid] = int(backend_prop.gate_length('u2', qid)) * 10**9 u2_err = backend_prop.gate_error('u2', qid) if u2_err == 1.0: u2_err = 0.9999 self.bp_u2_err = round(u2_err, NUM_PREC) self.bp_u3_dur[qid] = int(backend_prop.gate_length('u3', qid)) * 10**9 u3_err = backend_prop.gate_error('u3', qid) if u3_err == 1.0: u3_err = 0.9999 self.bp_u3_err = round(u3_err, NUM_PREC) for ginfo in backend_prop.gates: if ginfo.gate == 'cx': q_0 = ginfo.qubits[0] q_1 = ginfo.qubits[1] cx_tup = (min(q_0, q_1), max(q_0, q_1)) self.bp_cx_dur[cx_tup] = int( backend_prop.gate_length('cx', cx_tup)) * 10**9 cx_err = backend_prop.gate_error('cx', cx_tup) if cx_err == 1.0: cx_err = 0.9999 self.bp_cx_err[cx_tup] = round(cx_err, NUM_PREC) def cx_tuple(self, gate): """ Representation for two-qubit gate Note: current implementation assumes that the CX error rates and crosstalk behavior are independent of gate direction """ physical_q_0 = gate.qargs[0].index physical_q_1 = gate.qargs[1].index r_0 = min(physical_q_0, physical_q_1) r_1 = max(physical_q_0, physical_q_1) return (r_0, r_1) def singleq_tuple(self, gate): """ Representation for single-qubit gate """ physical_q_0 = gate.qargs[0].index tup = (physical_q_0, ) return tup def gate_tuple(self, gate): """ Representation for gate """ if len(gate.qargs) == 2: return self.cx_tuple(gate) else: return self.singleq_tuple(gate) def assign_gate_id(self, dag): """ ID for each gate """ idx = 0 for gate in dag.gate_nodes(): self.gate_id[gate] = idx idx += 1 def extract_dag_overlap_sets(self, dag): """ Gate A, B are overlapping if A is neither a descendant nor an ancestor of B. Currenty overlaps (A,B) are considered when A is a 2q gate and B is either 2q or 1q gate. """ for gate in dag.two_qubit_ops(): overlap_set = [] descendants = dag.descendants(gate) ancestors = dag.ancestors(gate) for tmp_gate in dag.gate_nodes(): if tmp_gate == gate: continue if tmp_gate in descendants: continue if tmp_gate in ancestors: continue overlap_set.append(tmp_gate) self.dag_overlap_set[gate] = overlap_set def is_significant_xtalk(self, gate1, gate2): """ Given two conditional gate error rates check if there is high crosstalk by comparing with independent error rates. """ gate1_tup = self.gate_tuple(gate1) if len(gate2.qargs) == 2: gate2_tup = self.gate_tuple(gate2) independent_err_g_1 = self.bp_cx_err[gate1_tup] independent_err_g_2 = self.bp_cx_err[gate2_tup] rg_1 = self.crosstalk_prop[gate1_tup][ gate2_tup] / independent_err_g_1 rg_2 = self.crosstalk_prop[gate2_tup][ gate1_tup] / independent_err_g_2 if rg_1 > TWOQ_XTALK_THRESH or rg_2 > TWOQ_XTALK_THRESH: return True else: gate2_tup = self.gate_tuple(gate2) independent_err_g_1 = self.bp_cx_err[gate1_tup] rg_1 = self.crosstalk_prop[gate1_tup][ gate2_tup] / independent_err_g_1 if rg_1 > ONEQ_XTALK_THRESH: return True return False def extract_crosstalk_relevant_sets(self): """ Extract the set of program gates which potentially have crosstalk noise """ for gate in self.dag_overlap_set: self.xtalk_overlap_set[gate] = [] tup_g = self.gate_tuple(gate) if tup_g not in self.crosstalk_prop: continue for par_g in self.dag_overlap_set[gate]: tup_par_g = self.gate_tuple(par_g) if tup_par_g in self.crosstalk_prop[tup_g]: if self.is_significant_xtalk(gate, par_g): if par_g not in self.xtalk_overlap_set[gate]: self.xtalk_overlap_set[gate].append(par_g) def create_z3_vars(self): """ Setup the variables required for Z3 optimization """ for gate in self.dag.gate_nodes(): t_var_name = 't_' + str(self.gate_id[gate]) d_var_name = 'd_' + str(self.gate_id[gate]) f_var_name = 'f_' + str(self.gate_id[gate]) self.gate_start_time[gate] = Real(t_var_name) self.gate_duration[gate] = Real(d_var_name) self.gate_fidelity[gate] = Real(f_var_name) for gate in self.xtalk_overlap_set: self.overlap_indicator[gate] = {} self.overlap_amounts[gate] = {} for g_1 in self.xtalk_overlap_set: for g_2 in self.xtalk_overlap_set[g_1]: if len(g_2.qargs) == 2 and g_1 in self.overlap_indicator[g_2]: self.overlap_indicator[g_1][g_2] = self.overlap_indicator[ g_2][g_1] self.overlap_amounts[g_1][g_2] = self.overlap_amounts[g_2][ g_1] else: # Indicator variable for overlap of g_1 and g_2 var_name1 = 'olp_ind_' + str( self.gate_id[g_1]) + '_' + str(self.gate_id[g_2]) self.overlap_indicator[g_1][g_2] = Bool(var_name1) var_name2 = 'olp_amnt_' + str( self.gate_id[g_1]) + '_' + str(self.gate_id[g_2]) self.overlap_amounts[g_1][g_2] = Real(var_name2) active_qubits_list = [] for gate in self.dag.gate_nodes(): for q in gate.qargs: active_qubits_list.append(q.index) for active_qubit in list(set(active_qubits_list)): q_var_name = 'l_' + str(active_qubit) self.qubit_lifetime[active_qubit] = Real(q_var_name) meas_q = [] for node in self.dag.op_nodes(): if isinstance(node.op, Measure): meas_q.append(node.qargs[0].index) self.measured_qubits = list( set(self.input_measured_qubits).union(set(meas_q))) self.measure_start = Real('meas_start') def basic_bounds(self): """ Basic variable bounds for optimization """ for gate in self.gate_start_time: self.opt.add(self.gate_start_time[gate] >= 0) for gate in self.gate_duration: q_0 = gate.qargs[0].index if isinstance(gate.op, U1Gate): dur = self.bp_u1_dur[q_0] elif isinstance(gate.op, U2Gate): dur = self.bp_u2_dur[q_0] elif isinstance(gate.op, U3Gate): dur = self.bp_u3_dur[q_0] elif isinstance(gate.op, CXGate): dur = self.bp_cx_dur[self.cx_tuple(gate)] self.opt.add(self.gate_duration[gate] == dur) def scheduling_constraints(self): """ DAG scheduling constraints optimization Sets overlap indicator variables """ for gate in self.gate_start_time: for dep_gate in self.dag.successors(gate): if not dep_gate.type == 'op': continue if isinstance(dep_gate.op, Measure): continue if isinstance(dep_gate.op, Barrier): continue fin_g = self.gate_start_time[gate] + self.gate_duration[gate] self.opt.add(self.gate_start_time[dep_gate] > fin_g) for g_1 in self.xtalk_overlap_set: for g_2 in self.xtalk_overlap_set[g_1]: if len(g_2.qargs ) == 2 and self.gate_id[g_1] > self.gate_id[g_2]: # Symmetry breaking: create only overlap variable for a pair # of gates continue s_1 = self.gate_start_time[g_1] f_1 = s_1 + self.gate_duration[g_1] s_2 = self.gate_start_time[g_2] f_2 = s_2 + self.gate_duration[g_2] # This constraint enforces full or zero overlap between two gates before = (f_1 < s_2) after = (f_2 < s_1) overlap1 = And(s_2 <= s_1, f_1 <= f_2) overlap2 = And(s_1 <= s_2, f_2 <= f_1) self.opt.add(Or(before, after, overlap1, overlap2)) intervals_overlap = And(s_2 <= f_1, s_1 <= f_2) self.opt.add( self.overlap_indicator[g_1][g_2] == intervals_overlap) def fidelity_constraints(self): """ Set gate fidelity based on gate overlap conditions """ for gate in self.gate_start_time: q_0 = gate.qargs[0].index no_xtalk = False if gate not in self.xtalk_overlap_set: no_xtalk = True elif not self.xtalk_overlap_set[gate]: no_xtalk = True if no_xtalk: if isinstance(gate.op, U1Gate): fid = math.log(1.0) elif isinstance(gate.op, U2Gate): fid = math.log(1.0 - self.bp_u2_err[q_0]) elif isinstance(gate.op, U3Gate): fid = math.log(1.0 - self.bp_u3_err[q_0]) elif isinstance(gate.op, CXGate): fid = math.log(1.0 - self.bp_cx_err[self.cx_tuple(gate)]) self.opt.add(self.gate_fidelity[gate] == round(fid, NUM_PREC)) else: comb = list(self.powerset(self.xtalk_overlap_set[gate])) xtalk_set = set(self.xtalk_overlap_set[gate]) for item in comb: on_set = item off_set = [i for i in xtalk_set if i not in on_set] clauses = [] for tmpg in on_set: clauses.append(self.overlap_indicator[gate][tmpg]) for tmpg in off_set: clauses.append(Not(self.overlap_indicator[gate][tmpg])) err = 0 if not on_set: err = self.bp_cx_err[self.cx_tuple(gate)] elif len(on_set) == 1: on_gate = on_set[0] err = self.crosstalk_prop[self.gate_tuple(gate)][ self.gate_tuple(on_gate)] else: err_list = [] for on_gate in on_set: tmp_prop = self.crosstalk_prop[self.gate_tuple( gate)] err_list.append(tmp_prop[self.gate_tuple(on_gate)]) err = max(err_list) if err == 1.0: err = 0.999999 val = round(math.log(1.0 - err), NUM_PREC) self.opt.add( Implies(And(*clauses), self.gate_fidelity[gate] == val)) def coherence_constraints(self): """ Set decoherence errors based on qubit lifetimes """ self.last_gate_on_qubit = {} for gate in self.dag.topological_op_nodes(): if isinstance(gate.op, Measure): continue if isinstance(gate.op, Barrier): continue if len(gate.qargs) == 1: q_0 = gate.qargs[0].index self.last_gate_on_qubit[q_0] = gate else: q_0 = gate.qargs[0].index q_1 = gate.qargs[1].index self.last_gate_on_qubit[q_0] = gate self.last_gate_on_qubit[q_1] = gate self.first_gate_on_qubit = {} for gate in self.dag.topological_op_nodes(): if len(gate.qargs) == 1: q_0 = gate.qargs[0].index if q_0 not in self.first_gate_on_qubit: self.first_gate_on_qubit[q_0] = gate else: q_0 = gate.qargs[0].index q_1 = gate.qargs[1].index if q_0 not in self.first_gate_on_qubit: self.first_gate_on_qubit[q_0] = gate if q_1 not in self.first_gate_on_qubit: self.first_gate_on_qubit[q_1] = gate for q in self.last_gate_on_qubit: g_last = self.last_gate_on_qubit[q] g_first = self.first_gate_on_qubit[q] finish_time = self.gate_start_time[g_last] + self.gate_duration[ g_last] start_time = self.gate_start_time[g_first] if q in self.measured_qubits: self.opt.add(self.measure_start >= finish_time) self.opt.add(self.qubit_lifetime[q] == self.measure_start - start_time) else: # All qubits get measured simultaneously whether or not they need a measurement self.opt.add(self.measure_start >= finish_time) self.opt.add(self.qubit_lifetime[q] == finish_time - start_time) def objective_function(self): """ Objective function is a weighted combination of gate errors and decoherence errors """ self.fidelity_terms = [ self.gate_fidelity[gate] for gate in self.gate_fidelity ] self.coherence_terms = [] for q in self.qubit_lifetime: val = -self.qubit_lifetime[q] / min(self.bp_t1_time[q], self.bp_t2_time[q]) self.coherence_terms.append(val) all_terms = [] for item in self.fidelity_terms: all_terms.append(self.weight_factor * item) for item in self.coherence_terms: all_terms.append((1 - self.weight_factor) * item) self.opt.maximize(Sum(all_terms)) def r2f(self, val): """ Convert Z3 Real to Python float """ return float(val.as_decimal(16).rstrip('?')) def extract_solution(self): """ Extract gate start and finish times from Z3 solution """ self.model = self.opt.model() result = {} for tmpg in self.gate_start_time: start = self.r2f(self.model[self.gate_start_time[tmpg]]) dur = self.r2f(self.model[self.gate_duration[tmpg]]) result[tmpg] = (start, start + dur) return result def solve_optimization(self): """ Setup and solve a Z3 optimization for finding the best schedule """ self.opt = Optimize() self.create_z3_vars() self.basic_bounds() self.scheduling_constraints() self.fidelity_constraints() self.coherence_constraints() self.objective_function() # Solve step self.opt.check() # Extract the schedule computed by Z3 result = self.extract_solution() return result def check_dag_dependency(self, gate1, gate2): """ gate2 is a DAG dependent of gate1 if it is a descendant of gate1 """ return gate2 in self.dag.descendants(gate1) def check_xtalk_dependency(self, t_1, t_2): """ Check if two gates have a crosstalk dependency. We do not consider crosstalk between pairs of single qubit gates. """ g_1 = t_1[0] s_1 = t_1[1] f_1 = t_1[2] g_2 = t_2[0] s_2 = t_2[1] f_2 = t_2[2] if len(g_1.qargs) == 1 and len(g_2.qargs) == 1: return False, () if s_2 <= f_1 and s_1 <= f_2: # Z3 says it's ok to overlap these gates, # so no xtalk dependency needs to be checked return False, () else: # Assert because we are iterating in Z3 gate start time order, # so if two gates are not overlapping, then the second gate has to # start after the first gate finishes assert s_2 >= f_1 # Not overlapping, but we care about this dependency if len(g_1.qargs) == 2 and len(g_2.qargs) == 2: if g_2 in self.xtalk_overlap_set[g_1]: cx1 = self.cx_tuple(g_1) cx2 = self.cx_tuple(g_2) barrier = tuple(sorted([cx1[0], cx1[1], cx2[0], cx2[1]])) return True, barrier elif len(g_1.qargs) == 1 and len(g_2.qargs) == 2: if g_1 in self.xtalk_overlap_set[g_2]: singleq = self.gate_tuple(g_1) cx1 = self.cx_tuple(g_2) print(singleq, cx1) barrier = tuple(sorted([singleq, cx1[0], cx1[1]])) return True, barrier elif len(g_1.qargs) == 2 and len(g_2.qargs) == 1: if g_2 in self.xtalk_overlap_set[g_1]: singleq = self.gate_tuple(g_2) cx1 = self.cx_tuple(g_1) barrier = tuple(sorted([singleq, cx1[0], cx1[1]])) return True, barrier # Not overlapping, and we don't care about xtalk between these two gates return False, () def filter_candidates(self, candidates, layer, layer_id, triplet): """ For a gate G and layer L, L is a candidate layer for G if no gate in L has a DAG dependency with G, and if Z3 allows gates in L and G to overlap. """ curr_gate = triplet[0] for prev_triplet in layer: prev_gate = prev_triplet[0] is_dag_dep = self.check_dag_dependency(prev_gate, curr_gate) is_xtalk_dep, _ = self.check_xtalk_dependency( prev_triplet, triplet) if is_dag_dep or is_xtalk_dep: # If there is a DAG dependency, we can't insert in any previous layer # If there is Xtalk dependency, we can (in general) insert in previous layers, # but since we are iterating in the order of gate start times, # we should only insert this gate in subsequent layers for i in range(layer_id + 1): if i in candidates: candidates.remove(i) return candidates def find_layer(self, layers, triplet): """ Find the appropriate layer for a gate """ candidates = list(range(len(layers))) for i, layer in enumerate(layers): candidates = self.filter_candidates(candidates, layer, i, triplet) if not candidates: return len(layers) # Open a new layer else: return max(candidates) # Latest acceptable layer, right-alignment def generate_barriers(self, layers): """ For each gate g, see if a barrier is required to serialize it with some previously processed gate """ barriers = [] for i, layer in enumerate(layers): barriers.append(set()) if i == 0: continue for t_2 in layer: for j in range(i): prev_layer = layers[j] for t_1 in prev_layer: is_dag_dep = self.check_dag_dependency(t_1[0], t_2[0]) is_xtalk_dep, curr_barrier = self.check_xtalk_dependency( t_1, t_2) if is_dag_dep: # Don't insert a barrier since there is a DAG dependency continue if is_xtalk_dep: # Insert a barrier for this layer barriers[-1].add(curr_barrier) return barriers def create_updated_dag(self, layers, barriers): """ Given a set of layers and barries, construct a new dag """ new_dag = DAGCircuit() for qreg in self.dag.qregs.values(): new_dag.add_qreg(qreg) for creg in self.dag.cregs.values(): new_dag.add_creg(creg) canonical_register = new_dag.qregs['q'] for i, layer in enumerate(layers): curr_barriers = barriers[i] for b in curr_barriers: current_qregs = [] for idx in b: current_qregs.append(canonical_register[idx]) new_dag.apply_operation_back(Barrier(len(b)), current_qregs, []) for triplet in layer: gate = triplet[0] new_dag.apply_operation_back(gate.op, gate.qargs, gate.cargs) for node in self.dag.op_nodes(): if isinstance(node.op, Measure): new_dag.apply_operation_back(node.op, node.qargs, node.cargs) return new_dag def enforce_schedule_on_dag(self, input_gate_times): """ Z3 outputs start times for each gate. Some gates need to be serialized to implement the Z3 schedule. This function inserts barriers to implement those serializations """ gate_times = [] for key in input_gate_times: gate_times.append( (key, input_gate_times[key][0], input_gate_times[key][1])) # Sort gates by start time sorted_gate_times = sorted(gate_times, key=operator.itemgetter(1)) layers = [] # Construct a set of layers. Each layer has a set of gates that # are allowed to fire in parallel according to Z3 for triplet in sorted_gate_times: layer_idx = self.find_layer(layers, triplet) if layer_idx == len(layers): layers.append([triplet]) else: layers[layer_idx].append(triplet) # Insert barries if necessary to enforce the above layers barriers = self.generate_barriers(layers) new_dag = self.create_updated_dag(layers, barriers) return new_dag def reset(self): """ Reset variables """ self.gate_id = {} self.gate_start_time = {} self.gate_duration = {} self.gate_fidelity = {} self.overlap_amounts = {} self.overlap_indicator = {} self.qubit_lifetime = {} self.dag_overlap_set = {} self.xtalk_overlap_set = {} self.measured_qubits = [] self.measure_start = None self.last_gate_on_qubit = None self.first_gate_on_qubit = None self.fidelity_terms = [] self.coherence_terms = [] self.model = None def run(self, dag): """ Main scheduling function """ if not HAS_Z3: raise TranspilerError( 'z3-solver is required to use CrosstalkAdaptiveSchedule. ' 'To install, run "pip install z3-solver".') self.dag = dag # process input program self.assign_gate_id(self.dag) self.extract_dag_overlap_sets(self.dag) self.extract_crosstalk_relevant_sets() # setup and solve a Z3 optimization z3_result = self.solve_optimization() # post-process to insert barriers new_dag = self.enforce_schedule_on_dag(z3_result) self.reset() return new_dag
def main(args): # print(args) seed = int(args[0]) random.seed(seed) # X is a three dimensional grid containing (t, x, y) X = [[[Bool("x_%s_%s_%s" % (k, i, j)) for j in range(GRID_SZ)] for i in range(GRID_SZ)] for k in range(HOPS + 1)] s = Optimize() # Initial Constraints s.add(X[0][0][0]) s.add([Not(cell) for row in X[0] for cell in row][1:]) # Final constraints s.add(X[HOPS][GRID_SZ - 1][GRID_SZ - 1]) s.add([Not(cell) for row in X[HOPS] for cell in row][:-1]) #Sanity Constraints for grid in X: for i in range(len(grid)): for j in range(len(grid)): for p in range(len(grid)): for q in range(len(grid)): if not (i == p and j == q): s.add(Not(And(grid[i][j], grid[p][q]))) #Motion primitives for t in range(HOPS): for x in range(GRID_SZ): for y in range(GRID_SZ): temp = Or(X[t][x][y]) if (x + 1 < GRID_SZ): temp = Or(temp, X[t][x + 1][y]) if (y + 1 < GRID_SZ): temp = Or(temp, X[t][x][y + 1]) if (x - 1 >= 0): temp = Or(temp, X[t][x - 1][y]) if (y - 1 >= 0): temp = Or(temp, X[t][x][y - 1]) s.add(simplify(Implies(X[t + 1][x][y], temp))) # Cost constraints for t in range(HOPS): for x in range(GRID_SZ): for y in range(GRID_SZ): s.add_soft(Not(X[t][x][y]), distance(x, y, GRID_SZ - 1, GRID_SZ - 1)) hop = 0 if s.check() == sat: m = s.model() else: print("No.of hops too low...") exit(1) obs1 = Obstacle(0, 3, GRID_SZ) robot_plan = [] obs_plan = [] # for a in s.assertions(): # print(a) while (hop < HOPS): robot_pos = (0, 0) if hop == 0 else get_robot_pos(m, hop) obs_pos = obs1.next_move() s.add(X[hop][robot_pos[0]][robot_pos[1]]) # print("hop is ", hop) # print("robot at ", robot_pos) # print("obs at ", obs_pos) if robot_pos == obs_pos: print("COLLISION!!!") print(robot_plan) print(obs_plan) exit() robot_plan.append(robot_pos) obs_plan.append(obs_pos) #next position of the robot next_robot_pos = get_robot_pos(m, hop + 1) s.push() # print("intersection points") # print(intersection_points(robot_pos, obs_pos)) # count = 0 next_overlap = next_intersection_points(next_robot_pos, obs_pos) for (x, y) in next_overlap: # consider only the intersection with the next step in the plan s.add(Not(X[hop + 1][x][y])) if len(next_overlap) > 0: # we need to find a new path if (s.check() == unsat): print("stay there") else: m = s.model() # print("Plan for hop = " + str(hop+1)) # print(get_plan(m)) hop += 1 else: # we don't need to worry about the path hop += 1 s.pop() robot_pos = get_robot_pos(m, hop) obs_pos = obs1.next_move() # print("hop is ", hop) # print("robot at ", robot_pos) # print("obs at ", obs_pos) robot_plan.append(robot_pos) obs_plan.append(obs_pos) if path_valid(robot_plan, obs_plan): print("PATH IS VALID!!!") else: print("PATH IS INVALID!!!") print("ROBOT MOVEMENT:") print(robot_plan) print("OBSTACLE MOVEMENT:") print(obs_plan)
if not l in intersects: intersects.append(l) # objective function O = [Int(i) * Int(j) - 1 for (i, j) in intersects] # constant indication how many variables wanted to change k = 10 opt.add(Sum(X) <= 2 * k) # print(opt.check()) # print(opt.model()) print("Begin Optimization: Maximize") # Calculate running time start_time = time.time() solution = opt.maximize(And(O)) print("--- %s seconds ---" % (time.time() - start_time)) if opt.check() == sat: while opt.check() == sat: print(solution.value()) else: print("Failed to solve.") m = opt.model() for x in street: print(m.evaluate(x))
def smt_solution(self, timeout, neg_points=None, optimize=False): # If halfspace's coefficients add to 1 it's # as simple as it gets normal_sum = sum(abs(x) for x in self.normal) if normal_sum == 0: return False elif normal_sum <= 1: simple = True else: simple = False neg_points = neg_points or [] if optimize: solver = Optimize() else: solver = Solver() solver.set("zero_accuracy",10) solver.set("timeout", timeout) ti = self.offset smt_ti = Int("b") if ti: solver.add(min(0,ti) <= smt_ti, smt_ti <= max(0,ti)) if optimize: # Try to minimize the independent term solver.minimize(smt_ti) else: solver.add(smt_ti == 0) variables = set() variables_positive = set() positive_x = True non_trivial = False some_consume = False some_produce = False diff_sol = smt_ti != ti smt_keep_sol = ti smt_is_sol = smt_ti for t_id, coeff in enumerate(self.normal): # SMT coefficient smt_coeff = Int("a%s" % t_id) if optimize: # Try to minimize the coefficient solver.minimize(smt_coeff) # SMT variable smt_var = Int("x%s"%t_id) # Add SMT varible to the set of variables variables.add(smt_var) # Add SMT varible basic constraint to the set variables_positive.add(smt_var >= 0) if coeff: # At least one SMT coefficient should be non zero non_trivial = Or(non_trivial, smt_coeff != 0) # At least one SMT coefficient should be different diff_sol = Or(diff_sol, smt_coeff != coeff) # Original solution with SMT variable smt_keep_sol += coeff * smt_var # SMT solution with SMT variable smt_is_sol += smt_coeff * smt_var # Keep SMT coefficient between original bundaries solver.add(min(0,coeff) <= smt_coeff, smt_coeff <= max(0, coeff)) if not neg_points and not simple: some_produce = Or(some_produce, smt_coeff > 0) some_consume = Or(some_consume, smt_coeff < 0) else: solver.add(smt_coeff == 0) #This is what we want: if not neg_points: # If there is not negative info, avoid trivial solution (i.e. Not all zero) solver.add(simplify(non_trivial)) if not simple: solver.add(simplify(some_consume)) solver.add(simplify(some_produce)) # A different solution (i.e. "better") solver.add(simplify(diff_sol)) # If it was a solution before, keep it that way solver.add(simplify(ForAll(list(variables), Implies(And(Or(list(variables_positive)), smt_keep_sol <= 0), smt_is_sol <= 0)))) # New solution shouldn't add a negative point for np in neg_points: smt_ineq_np = smt_ti ineq_np = ti for t_id, coeff in enumerate(self.normal): ineq_np += coeff * np[t_id] smt_coeff = Int("a%s"%(t_id)) smt_ineq_np += smt_coeff * np[t_id] # If neg point was out of this halfspace, keep it out! if ineq_np > 0: logger.info('Adding HS SMT-NEG restriction') solver.add(simplify(smt_ineq_np > 0)) sol = solver.check() if sol == unsat: ret = False logger.info('Z3 returns UNSAT: Cannot simplify HS without adding neg info') elif sol == unknown: ret = False logger.info('Z3 returns UNKNOWN: Cannot simplify HS in less than %s miliseconds', timeout) else: ret = solver.model() return ret
class StateProbabilityGenerator: def __init__(self, state_graph, statistics, settings, model_type): self.statistics = statistics self.state_graph = state_graph self.model_type = model_type logger.debug("Initialize oracle...") self._initialize_oracle(settings) logger.debug("Initialize obligation cache...") self._obligation_cache = ObligationCache() logger.debug("Initialize optimization solver...") # Initialize solver for optimization queries self.opt_solver = Optimize() self._realval_zero = RealVal(0) self._realval_one = RealVal(1) self.obligation_queue_class = settings.get_obligation_queue_class() def _initialize_oracle(self, settings): self.statistics.start_initialize_oracle_timer() args = [self.state_graph,settings.default_oracle_value,self.statistics,settings, self.model_type] if settings.oracle_type == "simulation": self.oracle = SimulationOracle(*args) elif settings.oracle_type == "perfect": self.oracle = ExactOracle(*args) elif settings.oracle_type == "modelchecking": self.oracle = ModelCheckingOracle(*args) elif settings.oracle_type == "solveeqspartly_exact" or settings.oracle_type == "solveeqspartly_inexact": self.oracle = SolveEQSPartlyOracle(*args) elif settings.oracle_type == "file": self.oracle = FileOracle(*args) else: raise RuntimeError("Unclear which oracle to use.") self.oracle.initialize() self.statistics.stop_initialize_oracle_timer() def refine_oracle(self, visited_states): res = self.oracle.refine_oracle(visited_states) self.reset_cache() return res def reset_cache(self): logger.debug("Reset obligation cache ...") self._obligation_cache.reset_cache() def finalize_statistics(self): self.statistics.set_number_oracle_states(len(self.oracle.oracle_states)) def run(self, state_id, chosen_command, delta, states_with_fixed_probabilities = set()): """ :param state_id: :param delta: :return: (1) True iff it is possible to find probabilities for the successors of the given state_id and delta. (2) If True, then it returns a dict form succ_ids to probabilities. This dict does not contain goal states. """ # TODO consider changing to None if not possible, and dict otherwise. self.statistics.inc_get_probability_counter() self.statistics.start_get_probability_timer() # First check whether we have cached the corresponding obligation res = self._obligation_cache.get_cached(state_id, chosen_command, delta) if res != False: self.statistics.stop_get_probability_timer() return (True, res) # If not, we have to ask the SMT-Solver succ_dist = self.state_graph.get_successors_filtered(state_id).by_command_index(chosen_command) succ_dist_without_target_states = [(state_id, prob) for (state_id, prob) in succ_dist if state_id != -1] # Check if there is at least one non-target state. Otherwise, repairing is not possible (smt solver would return unsat if we continued, so checking this is an optimization). if len(succ_dist_without_target_states) == 0: self.statistics.stop_get_probability_timer() return (False, None) self.opt_solver.push() vars = {} # We need a variable for each successor for (succ_id, prob) in succ_dist: if succ_id != -1: vars[succ_id] = Real("x_%s" % succ_id) # all results must of be probabilities self.opt_solver.add(vars[succ_id] >= self._realval_zero) self.opt_solver.add(vars[succ_id] <= self._realval_one) # \Phi(F)[s] = delta constraint # TODO: Type of porb is pycarl.gmp.gmp.Rational. Z3 magically deals with this self.opt_solver.add( Sum([ (vars[succ_id] if succ_id != -1 else RealVal(1)) * prob # Note: Keep in mind that you need to check whether succ is a target state for (succ_id, prob) in succ_dist ]) == delta) for (succ_id, prob) in succ_dist: if succ_id in states_with_fixed_probabilities: self.opt_solver.add(vars[succ_id] == self.obligation_queue_class.smallest_probability_for_state[succ_id]) # If we have more than one non-target successor, we have to optimize if len(succ_dist_without_target_states) > 1: # first check whether all oracle values are 0 (note that we do not have to do this if there is only one succ without target) if len(succ_dist_without_target_states) > 1 and sum([self.oracle.get_oracle_value(state_id).as_fraction() for state_id, prob in succ_dist_without_target_states]) == 0: # In this case, we require that the probability mass is distributed equally for i in range(0, len(succ_dist_without_target_states) - 1): self.opt_solver.add( vars[succ_dist_without_target_states[i][0]] == vars[succ_dist_without_target_states[i + 1][0]]) else: # First Try to solve the eq system # TODO: Do not use opt_solver for this if self._get_probabilities_by_solving_eq_system(succ_dist_without_target_states, vars): self.statistics.inc_solved_eq_system_instead_of_optimization_counter() m = self.opt_solver.model() result = { succ_id: m[vars[succ_id]] for (succ_id, prob) in succ_dist_without_target_states } # Because get_probabilities_by_solving_eq_system pushes # TODO: This is ugly # TODO: Compare solve-eq-system-time with optimization-problem-time self.opt_solver.pop() self.opt_solver.pop() self._obligation_cache.cache(state_id, chosen_command, delta, result) self.statistics.stop_get_probability_timer() return (True, result) else: self.statistics.inc_had_to_solve_optimization_problem_counter() # for each non-target-succ, we need n opt-var opt_vars = {} # For every non-target successor, we need an optimization variable for (succ_id, prob) in succ_dist_without_target_states: opt_vars[succ_id] = Real("opt_var_%s" % succ_id) # Now assert that opt_var_i = |var_i \ (var_1 + ... + var_n) - oracle(s_i) \ ( oracle(s_1) + ... + oracle(s_n ) | # for every opt_var_i for (succ_id, prob) in succ_dist_without_target_states: # opt_var is the absolute value of the ratio self.opt_solver.add( If(((vars[succ_id] * Sum([ self.oracle.get_oracle_value(succ_id_2) for (succ_id_2, prob) in succ_dist_without_target_states ])) - ((self.oracle.get_oracle_value(succ_id) * Sum([ vars[succ_id_2] for (succ_id_2, prob) in succ_dist_without_target_states ])))) < 0, opt_vars[succ_id] == (((self.oracle.get_oracle_value(succ_id) * Sum([ vars[succ_id_2] for (succ_id_2, prob) in succ_dist_without_target_states ]))) - (vars[succ_id] * Sum([ self.oracle.get_oracle_value(succ_id_2) for (succ_id_2, prob) in succ_dist_without_target_states ]))), opt_vars[succ_id] == ((vars[succ_id] * Sum([ self.oracle.get_oracle_value(succ_id_2) for (succ_id_2, prob) in succ_dist_without_target_states ])) - ((self.oracle.get_oracle_value(succ_id) * Sum([ vars[succ_id_2] for (succ_id_2, prob) in succ_dist_without_target_states ])))))) # minimize sum of opt-vars opt = self.opt_solver.minimize( Sum([ opt_vars[succ_id] for (succ_id, prob) in succ_dist_without_target_states ])) if self.opt_solver.check() == sat: # We found probabilities or the successors m = self.opt_solver.model() result = { succ_id: m[vars[succ_id]] for (succ_id, prob) in succ_dist_without_target_states } self.opt_solver.pop() self._obligation_cache.cache(state_id, chosen_command, delta, result) self.statistics.stop_get_probability_timer() return (True, result) else: # There are no such probabilities self.opt_solver.pop() self.statistics.stop_get_probability_timer() return (False, None) def _get_probabilities_by_solving_eq_system(self, succ_dist_without_target_states, vars): self.opt_solver.push() #TODO is this correct? lhs_sum = Sum([ self.oracle.get_oracle_value(succ_id_2) for (succ_id_2, _) in succ_dist_without_target_states ]) rhs_sum = Sum([ vars[succ_id_2] for (succ_id_2, _) in succ_dist_without_target_states ]) def _multiply(left,right): args = (Ast * 2)() args[0] = left.as_ast() args[1] = right.as_ast() return ArithRef(Z3_mk_mul(left.ctx.ref(), 2, args), left.ctx) for (succ_id, prob) in succ_dist_without_target_states: # opt_var is the absolute value of the ratio lhs = _multiply(vars[succ_id], lhs_sum) rhs = _multiply(self.oracle.get_oracle_value(succ_id), rhs_sum) equality = lhs == rhs self.opt_solver.add(equality) if self.opt_solver.check() == sat: return True else: self.opt_solver.pop() return False
class Oracle(ABC): """ An oracle is a dict from state_ids to values (not neccessarily probabilities since o.w. the eq system does not always have a solution). This is an abstract base class. Concrete sub-classes must overwrite `initialize`. Attributes: state_graph (StateGraph): the associated state graph default_value (Fraction): The default value is the oracle value returned if the given state_id is not a key of the oracle statistics (Statistics): access to the global statistics settings (Settings): all settings solver (Solver): a solver for the equation system oracle_states (Set[StateId]): states in this oracle oracle (Dict[StateId, z3.ExprRef]): the oracle's internal value dict """ def __init__(self, state_graph: StateGraph, default_value: Fraction, statistics: Statistics, settings: Settings, model_type: PrismModelType): self.state_graph = state_graph self.statistics = statistics self.settings = settings self.model_type = model_type if default_value < 0: raise ValueError("Oracle values must be greater or equal to 0") self.default_value = RealVal(default_value) self.solver = Solver() self.solver_mdp = Optimize() # The way we refine the Oracle depends on the model type if model_type == PrismModelType.DTMC: self.refine_oracle = self.refine_oracle_mc elif model_type == PrismModelType.MDP: self.refine_oracle = self.refine_oracle_mdp else: raise Exception("Oracle: Unsupported model type") self.oracle_states: Set[StateId] = set() self.oracle: Dict[StateId, z3.ExprRef] = dict() # self.save_oracle_on_disk() def _ensure_value_in_oracle(self, state_id: StateId): """ Used to override standard behaviour. Takes a state id, ensures that self.oracle contains this value. :param state_id: :return: """ pass def get_oracle_value(self, state_id: StateId) -> z3.ExprRef: if state_id not in self.oracle: self._ensure_value_in_oracle(state_id) return self.oracle.get(state_id, self.default_value) def refine_oracle_mc(self, visited_states: Set[StateId]) -> Set[StateId]: self.statistics.inc_refine_oracle_counter() # First ensure progress if visited_states <= self.oracle_states: # Ensure progress by adding all non-target successors of states in oracle_states to the set self.oracle_states = self.oracle_states.union({ succ_id for state_id in self.oracle_states for succ_id, prob in self.state_graph.get_filtered_successors(state_id) if succ_id != -1 }) else: self.oracle_states = self.oracle_states.union(visited_states) # TODO: A lot of optimization potential self.solver.push() # We need a variable for every oracle state variables = { state_id: Real("x_%s" % state_id) for state_id in self.oracle_states } # Set up EQ - System for state_id in self.oracle_states: self.solver.add(variables[state_id] == Sum([ RealVal(1) * prob if succ_id == -1 else # Case succ_id target state ( variables[succ_id] * prob if succ_id in self.oracle_states else # Case succ_id oracle state self.get_oracle_value(succ_id) * prob) # Case sycc_id no target and no oracle state for succ_id, prob in self.state_graph.get_filtered_successors( state_id) ])) self.solver.add(variables[state_id] >= RealVal(0)) #print(self.solver.assertions()) if self.solver.check() == sat: m = self.solver.model() # update oracle for state_id in self.oracle_states: self.oracle[state_id] = m[variables[state_id]] logger.info("Refined oracle.") #logger.info(self.oracle) self.solver.pop() return self.oracle_states else: # The oracle solver is unsat. In this case, we solve the LP. self.solver.pop() self.statistics.refine_oracle_counter = self.statistics.refine_oracle_counter - 1 return self.refine_oracle_mdp(visited_states) def refine_oracle_mdp(self, visited_states: Set[StateId]) -> Set[StateId]: self.statistics.inc_refine_oracle_counter() # First ensure progress if visited_states <= self.oracle_states: # Ensure progress by adding all non-target successors of states in oracle_states to the set (for every action) self.oracle_states = self.oracle_states.union({ succ[0] for state_id in self.oracle_states for choice in self.state_graph.get_successors_filtered(state_id).choices for succ in choice.distribution if succ[0] != -1 }) else: self.oracle_states = self.oracle_states.union(visited_states) # TODO: A lot of optimization potential self.solver_mdp.push() # We need a variable for every oracle state variables = { state_id: Real("x_%s" % state_id) for state_id in self.oracle_states } # Set up EQ - System for state_id in self.oracle_states: for choice in self.state_graph.get_successors_filtered( state_id).choices: self.solver_mdp.add(variables[state_id] >= Sum([ RealVal(1) * prob if succ_id == -1 else # Case succ_id target state ( variables[succ_id] * prob if succ_id in self.oracle_states else # Case succ_id oracle state self.get_oracle_value(succ_id) * prob) # Case sycc_id no target and no oracle state for succ_id, prob in choice.distribution ])) self.solver_mdp.add(variables[state_id] >= RealVal(0)) # Minimize value for initial state self.solver_mdp.minimize( variables[self.state_graph.get_initial_state_id()]) if self.solver_mdp.check() == sat: m = self.solver_mdp.model() # update oracle for state_id in self.oracle_states: self.oracle[state_id] = m[variables[state_id]] logger.info("Refined oracle.") # logger.info(self.oracle) self.solver_mdp.pop() return self.oracle_states else: logger.error("Oracle solver unsat") raise RuntimeError("Oracle solver inconsistent.") @abstractmethod def initialize(self): """ Stub to be overwritten by concrete oracles. :return: """ pass def save_oracle_on_disk(self): """ Save this oracle to disk using `save_oracle_dict` from `pric3.oracles.file_oracle`. """ from pric3.oracles.file_oracle import save_oracle_dict save_oracle_dict(self.state_graph, self.oracle) def _get_prism_program(self): return self.state_graph.input_program.prism_program
if not l in intersects: intersects.append(l) # objective function O = [ Int(i)*Int(j) - 1 for (i, j) in intersects ] # constant indication how many variables wanted to change k = 10 opt.add( Sum(X) <= 2*k ) # print(opt.check()) # print(opt.model()) print("Begin Optimization: Maximize") # Calculate running time start_time = time.time() solution = opt.maximize( And(O) ) print("--- %s seconds ---" % (time.time() - start_time)) if opt.check() == sat: while opt.check() == sat: print(solution.value()) else: print("Failed to solve.") m = opt.model() for x in street: print( m.evaluate(x) )
from z3 import Optimize, Real, If x = Real('x') y = Real('y') z = Real('z') def z3abs(obj): return If(x > 0, x, -x) optimizer = Optimize() # optimizer.add(x>0.0) # optimizer.add(y>0.0) optimizer.add(x*x+y*y==1.0) optimizer.add_soft(z == x+y) optimizer.maximize(z) result = optimizer.check() print(optimizer.model())
return If(x >= 0, x, -x) def z3_dist(v1, v2): return z3_abs(v1.x - v2.x) + z3_abs(v1.y - v2.y) + z3_abs(v1.z - v2.z) x = Int('x') y = Int('y') z = Int('z') orig = (x, y, z) cost = Int('cost') cost_expr = 0 for bot in bots: cost_expr += If(z3_dist(Vector3(*orig), bot.pos) <= bot.r, 1, 0) opt = Optimize() print("let's go") opt.add(cost == cost_expr) opt.maximize(cost) opt.minimize(z3_dist(Vector3(0, 0, 0), Vector3(x, y, z))) opt.check() model = opt.model() print(model) pos = (model[x].as_long(), model[y].as_long(), model[z].as_long()) print("position:", pos) print("num in range:", model[cost].as_long()) print("distance:", l1(Vector3(0, 0, 0), Vector3(*pos)))
def smt_solution(self, timeout, optimize=False): if optimize: solver = Optimize() else: solver = Solver() solver.set("zero_accuracy",10) solver.set("timeout", timeout) non_trivial = False diff_sol = False smt_keep_sol = True # a.k.a A1 smt_is_sol = True # a.k.a A2 some_consume = False some_produce = False variables = set() variables_positive = set() for p_id, place in enumerate(self.facets): ti = place.offset smt_ti = Int("b%s" % p_id) if ti: solver.add(min(0,ti) <= smt_ti, smt_ti <= max(0, ti)) else: solver.add(smt_ti == 0) facet_non_trivial = False facet_diff_sol = False smt_facet_eval = ti smt_facet_sol = ti # If halfspace's coefficients add to 1 it's # as simple as it gets simple = sum(abs(x) for x in place.normal) <= 1 # do_cons_prod indicates if the place has incoming and outgoing transitions do_cons_prod = False consume = produce = 0 for coeff in place.normal: if coeff > 0: produce = 1 elif coeff < 0: consume = 1 if consume * produce: do_cons_prod = True break do_cons_prod = reduce(lambda x,y:x*y, [x + 1 for x in place.normal]) < 1 for t_id, coeff in enumerate(place.normal): # SMT coefficient smt_coeff = Int("a%s,%s" % (p_id, t_id)) if optimize: # Try to minimize the coefficient solver.minimize(smt_coeff) # SMT variable smt_var = Int("x%s" % t_id) # Add SMT varible to the set of variables variables.add(smt_var) # Add SMT varible basic constraint to the set variables_positive.add(smt_var >= 0) if coeff: # At least one SMT coefficient should be non zero facet_non_trivial = Or(facet_non_trivial, smt_coeff != 0) # At least one SMT coefficient should be different facet_diff_sol = Or(facet_diff_sol, smt_coeff != coeff) # Original solution with SMT variable smt_facet_eval += coeff * smt_var # SMT solution with SMT variable smt_facet_sol += smt_coeff * smt_var # Keep SMT coefficient between original bundaries solver.add(min(0,coeff) <= smt_coeff, smt_coeff <= max(0, coeff)) if not self.neg_points and not simple and do_cons_prod: some_produce = Or(some_produce, smt_coeff > 0) some_consume = Or(some_consume, smt_coeff < 0) else: # Keep zero coefficients unchanged solver.add(smt_coeff == 0) if not self.neg_points: # Avoid trivial solution (i.e. all zeros as coeff) non_trivial = Or(non_trivial, facet_non_trivial) # Solution of smt must be different diff_sol = Or(diff_sol, facet_diff_sol) # If point is in old-solution should be in smt-solution smt_keep_sol = And(smt_keep_sol, smt_facet_eval <= 0) # Solutions shoul be a solution smt_is_sol = And(smt_is_sol, smt_facet_sol <= 0) if not self.neg_points and not simple and do_cons_prod: solver.add(simplify(some_consume)) solver.add(simplify(some_produce)) if optimize: # Try to minimize the independent term solver.minimize(smt_ti) # This is what we want: if not self.neg_points: # If there is not negative info, avoid trivial solution (i.e. Not all zero) solver.add(simplify(non_trivial)) # A different solution (i.e. "better") solver.add(simplify(diff_sol)) # If it was a solution before, keep it that way solver.add(simplify(ForAll(list(variables), Implies(And(Or(list(variables_positive)), smt_keep_sol), smt_is_sol)))) # Negative point shouldn't be a solution for np in self.neg_points: smt_np = False for p_id, place in enumerate(self.facets): place_at_np = Int("b%s" % p_id) for t_id, coeff in enumerate(place.normal): # If coefficient was zero, it will remain zero if coeff and np[t_id]: smt_coeff = Int("a%s,%s" % (p_id, t_id)) place_at_np = place_at_np + smt_coeff * np[t_id] smt_np = Or(smt_np, place_at_np > 0) # Keep out (NOTE halfspaces are Ax + b <= 0) solver.add(simplify(smt_np)) sol = solver.check() if sol == unsat: ret = False logger.info('Z3 returns UNSAT: Cannot reduce without adding neg info') elif sol == unknown: ret = False logger.info('Z3 returns UNKNOWN: Cannot reduce in less than %s miliseconds', timeout) else: ret = solver.model() return ret
# z3.minimize(depth) if objective_name == "swap": z3.minimize(num_swap) elif objective_name == "depth": ze.minimize(depth) satisfiable = z3.check() if satisfiable == sat: not_solve = False else: T += 1 print("Compilation time = {}.".format(sys_time.time() - start_time)) model = z3.model() if objective_name == "fidelity": log_fidelity = model[fidelity].as_long() print("result fidelity = {}".format(math.exp(log_fidelity / 1000.0))) for k in range(K): tmp0 = model[v[k]].as_long() tmp1 = model[vv[k]].as_long() if (tmp0 != 0) or (tmp1 != 0): print("On edge {}, there are {} two-qubit gates and {} SWAP gates.".format(k, tmp0, tmp1)) for n in range(N): tmp0 = model[u[n]].as_long() tmp1 = model[w[n]].as_long() if (tmp0 != 0) or (tmp1 != 0): print("On node {}, there are {} single-qubit gates and {} measurement.".format(n, tmp0, tmp1)) elif objective_name == "swap": print("result additional SWAP count = {}.".format(model[num_swap]))
globals()[abc[i]] = Int(abc[i]) l.append(abc[i]) s.add(And(d[abc[i]] >= 0, d[abc[i]] <= n - 1)) s.add(Distinct([d[x] for x in l])) for i in superstring.split(' '): s.add( Int('diff_{0}_{1}'.format(i[0], i[1])) == diff(d.get(i[0]), d.get( i[1]))) try: final_sum += Int('diff_{0}_{1}'.format(i[0], i[1])) * int(i[2]) except NameError: final_sum = Int('diff_{0}_{1}'.format(i[0], i[1])) * int(i[2]) final_sum2 = Int("final_sum2") s.add(final_sum == final_sum2) s.minimize(final_sum) s.check() m = s.model() a = {} for i in l: a[m[d[i]].as_long()] = str(i) for i in range(n): print(a[i]) print('Minimum number of cables: {0}'.format(m[final_sum2]))
def main(args): # print(args) seed = int(args[0]) random.seed(seed) GRID_SZ = int(args[1]) HOPS = int(args[2]) print("WORKSPACE SIZE (%s x %s)" % (GRID_SZ, GRID_SZ)) print("HOPS ALLOWED = %s" % (HOPS)) # X is a three dimensional grid containing (t, x, y) X = [ [ [ Bool("x_%s_%s_%s" % (k, i, j)) for j in range(GRID_SZ) ] for i in range(GRID_SZ) ] for k in range(HOPS+1)] s = Optimize() # Initial Constraints s.add(X[0][0][0]) s.add([Not(cell) for row in X[0] for cell in row][1:]) # Final constraints s.add(X[HOPS][GRID_SZ-1][GRID_SZ-1]) s.add([Not(cell) for row in X[HOPS] for cell in row][:-1]) #Sanity Constraints for grid in X: for i in range(len(grid)): for j in range(len(grid)): for p in range(len(grid)): for q in range(len(grid)): if not (i==p and j==q): s.add(Not(And(grid[i][j], grid[p][q]))) #Motion primitives for t in range(HOPS): for x in range(GRID_SZ): for y in range(GRID_SZ): temp = Or(X[t][x][y]) if (x+1 < GRID_SZ): temp = Or(temp, X[t][x+1][y]) if (y+1 < GRID_SZ): temp = Or(temp, X[t][x][y+1]) if (x-1 >= 0): temp = Or(temp, X[t][x-1][y]) if (y-1 >= 0): temp = Or(temp, X[t][x][y-1]) s.add(simplify(Implies(X[t+1][x][y], temp))) # Cost constraints for t in range(HOPS): for x in range(GRID_SZ): for y in range(GRID_SZ): s.add_soft(Not(X[t][x][y]), distance(x, y, GRID_SZ-1, GRID_SZ-1)) if s.check() == sat: m = s.model() else: print("No.of hops too low...") exit(1) # obs1 = Obstacle(0, 3, GRID_SZ) obs = [Obstacle(3, 3, GRID_SZ), Obstacle(4, 5, GRID_SZ), Obstacle(6, 7, GRID_SZ), Obstacle(8, 9, GRID_SZ), Obstacle(9, 3, GRID_SZ), Obstacle(1, 8, GRID_SZ), Obstacle(7, 7, GRID_SZ)] # obs = [Obstacle(3, 3, GRID_SZ)] ## # obs = [] # for i in range(0, GRID_SZ-1): # for j in range(0, GRID_SZ-1): # if (i+j)%3 != 0: # print(i, j) # obs.append(Obstacle(i, j, GRID_SZ)) # print("-----") robot_plan = [] hop = 0 stay_count = 0 # obs_plan = [] # for a in s.assertions(): # print(a) while (hop < HOPS): # print("hops = ", hop) if stay_count > 0: robot_pos = [robot_plan[-stay_count][0], robot_plan[-stay_count][1]] next_robot_pos = get_robot_pos(m,hop-stay_count) else: robot_pos = get_robot_pos(m,hop) next_robot_pos = get_robot_pos(m,hop+1) # print("robot_pos = ", robot_pos) # for obstacle in obs: # print("Obstacle at ", (obstacle.x, obstacle.y)) # print('-----------') s.add(X[hop][robot_pos[0]][robot_pos[1]]) robot_plan.append(robot_pos) # obs_plan.append(obs_pos) #next position of the robot # if (stay: # s.push() # print("intersection points") # print(intersection_points(robot_pos, obs_pos)) # count = 0 # print("blah!!!") next_overlap = [] for obstacle in obs: next_overlap = next_overlap + next_intersection_points(robot_pos, (obstacle.x, obstacle.y)) # print("Lenght = ", len(next_overlap)) for (x, y) in next_overlap: # consider only the intersection with the next step in the plan if ((0 <= x < GRID_SZ) and (0 <= y < GRID_SZ)): s.add(Not(X[hop+1][x][y])) # print("ceeeee!!", next_robot_pos in set(next_overlap)) if next_robot_pos in set(next_overlap): # we need to find a new path # print("just before check") if (s.check() == unsat): print("stay there") print(robot_pos) stay_count += 1 # hop -= 1 hop += 1 else: stay_count = 0 m = s.model() hop += 1 # print("just after check") else: # we don't need to worry about the path hop += 1 # print('dssdfdsfds') # s.pop() for obstacle in obs: # print("12") obstacle.next_move() if (stay_count > 0): return 1 robot_pos = get_robot_pos(m,hop) for obstacle in obs: obstacle.next_move() # print("hop is ", hop) # print("robot at ", robot_pos) # print("obs at ", obs_pos) robot_plan.append(robot_pos) # obs_plan.append(obs_pos) for obstacle in obs: if not path_valid(robot_plan, obstacle.path): print("PATH IS INVALID!!!") print("ROBOT MOVEMENT:") print(robot_plan) print("OBSTACLE MOVEMENT:") for obstacle in obs: print(obstacle.path)
def solve(self, output_mode=None, output_file_name=None): objective_name = self.objective_name device = self.device list_gate_qubits = self.list_gate_qubits count_program_qubit = self.count_program_qubit list_gate_name = self.list_gate_name count_physical_qubit = self.count_physical_qubit list_qubit_edge = self.list_qubit_edge swap_duration = self.swap_duration bound_depth = self.bound_depth """ pre-processing """ count_qubit_edge = len(list_qubit_edge) count_gate = len(list_gate_qubits) if self.objective_name == "fidelity": list_logfidelity_single = [ int(1000 * math.log(device.list_fidelity_single[n])) for n in range(count_physical_qubit) ] list_logfidelity_two = [ int(1000 * math.log(device.list_fidelity_two[k])) for k in range(count_qubit_edge) ] list_logfidelity_measure = [ int(1000 * math.log(device.list_fidelity_measure[n])) for n in range(count_physical_qubit) ] list_gate_two = list() list_gate_single = list() for l in range(count_gate): if isinstance(list_gate_qubits[l], int): list_gate_single.append(l) else: list_gate_two.append(l) # list_adjacency_qubit takes in a physical qubit index _p_, and returns the list of indices of # physical qubits adjacent to _p_ list_adjacent_qubit = list() # list_span_edge takes in a physical qubit index _p_, and returns the list of edges spanned from _p_ list_span_edge = list() for n in range(count_physical_qubit): list_adjacent_qubit.append(list()) list_span_edge.append(list()) for k in range(count_qubit_edge): list_adjacent_qubit[list_qubit_edge[k][0]].append( list_qubit_edge[k][1]) list_adjacent_qubit[list_qubit_edge[k][1]].append( list_qubit_edge[k][0]) list_span_edge[list_qubit_edge[k][0]].append(k) list_span_edge[list_qubit_edge[k][1]].append(k) # if_overlap_edge takes in two edge indices _e_ and _e'_, and returns whether or not they overlap if_overlap_edge = [[0] * count_qubit_edge for k in range(count_qubit_edge)] # list_over_lap_edge takes in an edge index _e_, and returns the list of edges that overlap with _e_ list_overlap_edge = list() # list_count_overlap_edge is the list of lengths of overlap edge lists of all the _e_ list_count_overlap_edge = list() for k in range(count_qubit_edge): list_overlap_edge.append(list()) for k in range(count_qubit_edge): for kk in range(k + 1, count_qubit_edge): if (list_qubit_edge[k][0] == list_qubit_edge[kk][0] or list_qubit_edge[k][0] == list_qubit_edge[kk][1]) \ or (list_qubit_edge[k][1] == list_qubit_edge[kk][0] or list_qubit_edge[k][1] == list_qubit_edge[kk][1]): list_overlap_edge[k].append(kk) list_overlap_edge[kk].append(k) if_overlap_edge[kk][k] = 1 if_overlap_edge[k][kk] = 1 for k in range(count_qubit_edge): list_count_overlap_edge.append(len(list_overlap_edge[k])) # list_gate_dependency is the list of dependency, pairs of gate indices (_l_, _l'_), where _l_<_l'_ # _l_ and _ll_ act on a same program qubit list_gate_dependency = collision_extracting(list_gate_qubits) # index function: it takes two physical qubit indices _p_ and _p'_, # and returns the index of the edge between _p_ and _p'_, if there is one map_edge_index = [[0] * count_physical_qubit] * count_physical_qubit for k in range(count_qubit_edge): map_edge_index[list_qubit_edge[k][0]][list_qubit_edge[k][1]] = k map_edge_index[list_qubit_edge[k][1]][list_qubit_edge[k][0]] = k not_solved = True while not_solved: print("Trying maximal depth = {}...".format(bound_depth)) """ variables """ # at cycle t, logical qubit q is mapped to pi[q][t] pi = [[ Int("map_q{}_t{}".format(i, j)) for j in range(bound_depth) ] for i in range(count_program_qubit)] # time coordinate for gate l is time[l] time = IntVector('time', count_gate) # space coordinate for gate l is space[l] space = IntVector('space', count_gate) # if at cycle t, there is a SWAP finishing on edge k, then sigma[k][t]=1 sigma = [[ Bool("ifswap_e{}_t{}".format(i, j)) for j in range(bound_depth) ] for i in range(count_qubit_edge)] # for depth optimization depth = Int('depth') # for swap optimization count_swap = Int('num_swap') # for fidelity optimization if objective_name == "fidelity": u = [ Int("num_1qbg_p{}".format(n)) for n in range(count_physical_qubit) ] v = [ Int("num_2qbg_e{}".format(k)) for k in range(count_qubit_edge) ] vv = [ Int("num_swap_e{}".format(k)) for k in range(count_qubit_edge) ] w = [ Int("num_meas_p{}".format(n)) for n in range(count_physical_qubit) ] fidelity = Int('log_fidelity') lsqc = Optimize() """ Constraints """ for t in range(bound_depth): for m in range(count_program_qubit): lsqc.add(pi[m][t] >= 0, pi[m][t] < count_physical_qubit) for mm in range(m): lsqc.add(pi[m][t] != pi[mm][t]) for l in range(count_gate): lsqc.add(time[l] >= 0, time[l] < bound_depth) if l in list_gate_single: lsqc.add(space[l] >= 0, space[l] < count_physical_qubit) for t in range(bound_depth): lsqc.add( Implies(time[l] == t, pi[list_gate_qubits[l]][t] == space[l])) elif l in list_gate_two: lsqc.add(space[l] >= 0, space[l] < count_qubit_edge) for k in range(count_qubit_edge): for t in range(bound_depth): lsqc.add( Implies( And(time[l] == t, space[l] == k), Or( And( list_qubit_edge[k][0] == pi[ list_gate_qubits[l][0]][t], list_qubit_edge[k][1] == pi[ list_gate_qubits[l][1]][t]), And( list_qubit_edge[k][1] == pi[ list_gate_qubits[l][0]][t], list_qubit_edge[k][0] == pi[ list_gate_qubits[l][1]][t])))) for d in list_gate_dependency: if self.if_transition_based == True: lsqc.add(time[d[0]] <= time[d[1]]) else: lsqc.add(time[d[0]] < time[d[1]]) for t in range(min(swap_duration - 1, bound_depth)): for k in range(count_qubit_edge): lsqc.add(sigma[k][t] == False) for t in range(swap_duration - 1, bound_depth): for k in range(count_qubit_edge): for tt in range(t - swap_duration + 1, t): lsqc.add( Implies(sigma[k][t] == True, sigma[k][tt] == False)) for tt in range(t - swap_duration + 1, t + 1): for kk in list_overlap_edge[k]: lsqc.add( Implies(sigma[k][t] == True, sigma[kk][tt] == False)) if self.if_transition_based == False: for t in range(swap_duration - 1, bound_depth): for k in range(count_qubit_edge): for tt in range(t - swap_duration + 1, t + 1): for l in range(count_gate): if l in list_gate_single: lsqc.add( Implies( And( time[l] == tt, Or( space[l] == list_qubit_edge[k][0], space[l] == list_qubit_edge[k][1])), sigma[k][t] == False)) elif l in list_gate_two: lsqc.add( Implies( And(time[l] == tt, space[l] == k), sigma[k][t] == False)) for kk in list_overlap_edge[k]: lsqc.add( Implies( And(time[l] == tt, space[l] == kk), sigma[k][t] == False)) for t in range(bound_depth - 1): for n in range(count_physical_qubit): for m in range(count_program_qubit): lsqc.add( Implies( And( sum([ If(sigma[k][t], 1, 0) for k in list_span_edge[n] ]) == 0, pi[m][t] == n), pi[m][t + 1] == n)) for t in range(bound_depth - 1): for k in range(count_qubit_edge): for m in range(count_program_qubit): lsqc.add( Implies( And(sigma[k][t] == True, pi[m][t] == list_qubit_edge[k][0]), pi[m][t + 1] == list_qubit_edge[k][1])) lsqc.add( Implies( And(sigma[k][t] == True, pi[m][t] == list_qubit_edge[k][1]), pi[m][t + 1] == list_qubit_edge[k][0])) lsqc.add(count_swap == sum([ If(sigma[k][t], 1, 0) for k in range(count_qubit_edge) for t in range(bound_depth) ])) # for depth optimization for l in range(count_gate): lsqc.add(depth >= time[l] + 1) if objective_name == "swap": lsqc.minimize(count_swap) elif objective_name == "depth": lsqc.minimize(depth) elif objective_name == "fidelity": for n in range(count_physical_qubit): lsqc.add(u[n] == sum( [If(space[l] == n, 1, 0) for l in list_gate_single])) lsqc.add(w[n] == sum([ If(pi[m][bound_depth - 1] == n, 1, 0) for m in range(count_program_qubit) ])) for k in range(count_qubit_edge): lsqc.add(v[k] == sum( [If(space[l] == k, 1, 0) for l in list_gate_two])) lsqc.add(vv[k] == sum( [If(sigma[k][t], 1, 0) for t in range(bound_depth)])) lsqc.add(fidelity == sum([ v[k] * list_logfidelity_two[k] for k in range(count_qubit_edge) ]) + sum([ swap_duration * vv[k] * list_logfidelity_two[k] for k in range(count_qubit_edge) ]) + sum([ w[n] * list_logfidelity_measure[n] for n in range(count_physical_qubit) ]) + sum([ u[n] * list_logfidelity_single[n] for n in range(count_physical_qubit) ])) lsqc.maximize(fidelity) else: raise Exception("Invalid Objective Name") satisfiable = lsqc.check() if satisfiable == sat: not_solved = False else: if self.if_transition_based == True: bound_depth += 1 else: bound_depth = int(1.3 * bound_depth) # print("Compilation time = {}s.".format(sys_time.time() - start_time)) model = lsqc.model() """ post-processing """ result_time = [] result_depth = model[depth].as_long() for l in range(count_gate): result_time.append(model[time[l]].as_long()) list_result_swap = [] for k in range(count_qubit_edge): for t in range(result_depth): if model[sigma[k][t]]: list_result_swap.append((k, t)) # transition based if self.if_transition_based: self.swap_duration = self.device.swap_duration map_to_block = dict() real_time = [0 for i in range(count_gate)] list_depth_on_qubit = [-1 for i in range(self.count_program_qubit)] list_real_swap = [] for block in range(result_depth): for tmp_gate in range(count_gate): if result_time[tmp_gate] == block: qubits = list_gate_qubits[tmp_gate] if isinstance(qubits, int): real_time[ tmp_gate] = list_depth_on_qubit[qubits] + 1 list_depth_on_qubit[qubits] = real_time[tmp_gate] map_to_block[real_time[tmp_gate]] = block else: real_time[tmp_gate] = list_depth_on_qubit[ qubits[0]] + 1 if real_time[tmp_gate] < list_depth_on_qubit[ qubits[1]] + 1: real_time[tmp_gate] = list_depth_on_qubit[ qubits[1]] + 1 list_depth_on_qubit[ qubits[0]] = real_time[tmp_gate] list_depth_on_qubit[ qubits[1]] = real_time[tmp_gate] map_to_block[real_time[tmp_gate]] = block if block < result_depth - 1: for (k, t) in list_result_swap: if t == block: q0 = list_qubit_edge[k][0] q1 = list_qubit_edge[k][1] tmp_time = list_depth_on_qubit[ q0] + self.swap_duration if tmp_time < list_depth_on_qubit[ q1] + self.swap_duration: tmp_time = list_depth_on_qubit[ q1] + self.swap_duration list_depth_on_qubit[q0] = tmp_time list_depth_on_qubit[q1] = tmp_time list_real_swap.append((k, tmp_time)) result_time = real_time real_depth = 0 for tmp_depth in list_depth_on_qubit: if real_depth < tmp_depth + 1: real_depth = tmp_depth + 1 result_depth = real_depth list_result_swap = list_real_swap if objective_name == "fidelity": log_fidelity = model[fidelity].as_long() print("result fidelity = {}".format(math.exp(log_fidelity / 1000.0))) elif objective_name == "swap": print("result additional SWAP count = {}.".format( len(list_result_swap))) else: print("result circuit depth = {}.".format(result_depth)) list_scheduled_gate_qubits = [[] for i in range(result_depth)] list_scheduled_gate_name = [[] for i in range(result_depth)] result_depth = 0 for l in range(count_gate): t = result_time[l] if result_depth < t + 1: result_depth = t + 1 list_scheduled_gate_name[t].append(list_gate_name[l]) if l in list_gate_single: q = model[space[l]].as_long() list_scheduled_gate_qubits[t].append(q) elif l in list_gate_two: [q0, q1] = list_gate_qubits[l] tmp_t = t if self.if_transition_based: tmp_t = map_to_block[t] q0 = model[pi[q0][tmp_t]].as_long() q1 = model[pi[q1][tmp_t]].as_long() list_scheduled_gate_qubits[t].append([q0, q1]) else: raise Exception("Expect single- or two-qubit gate.") final_mapping = [] for m in range(count_program_qubit): tmp_depth = result_depth - 1 if self.if_transition_based: tmp_depth = map_to_block[result_depth - 1] final_mapping.append(model[pi[m][tmp_depth]].as_long()) # print("logical qubit {} is mapped to node {} in the beginning, node {} at the end".format( # m, model[pi[m][0]], model[pi[m][result_depth - 1]])) for (k, t) in list_result_swap: q0 = list_qubit_edge[k][0] q1 = list_qubit_edge[k][1] if self.swap_duration == 1: list_scheduled_gate_qubits[t].append([q0, q1]) list_scheduled_gate_name[t].append("SWAP") elif self.swap_duration == 3: list_scheduled_gate_qubits[t].append([q0, q1]) list_scheduled_gate_name[t].append("cx") list_scheduled_gate_qubits[t - 1].append([q1, q0]) list_scheduled_gate_name[t - 1].append("cx") list_scheduled_gate_qubits[t - 2].append([q0, q1]) list_scheduled_gate_name[t - 2].append("cx") else: raise Exception( "Expect SWAP duration one, or three (decomposed into CX gates)" ) if output_mode == "IR": if output_file_name: output_file = open(output_file_name, 'w') output_file.writelines([ result_depth, list_scheduled_gate_name, list_scheduled_gate_qubits, final_mapping ]) return [ result_depth, list_scheduled_gate_name, list_scheduled_gate_qubits, final_mapping ] else: return output_qasm(self.device, result_depth, list_scheduled_gate_name, list_scheduled_gate_qubits, final_mapping, True, output_file_name)