def by_amplify_limited(list_dependent_variables, num_registers, limitation): num_variables = len(list_dependent_variables) q = gen_symbols(BinaryPoly, num_variables, num_registers) # 各変数を1つのレジスタに割り当てるOne-het制約 const_onehot = [ equal_to(sum_poly([q[i][r] for r in range(num_registers)]), 1) for i in range(num_variables) ] # レジスタスピルを減らすために,依存関係のある変数同士が同一のレジスタに割り当てられない制約 const_spill = [ penalty(q[i][r] * q[j][r]) for i in range(num_variables) for j in list_dependent_variables[i] if i < j for r in range(num_registers) ] # ある変数が割り当てられるレジスタがわかっている時,必ずそのレジスタに割り当てられるようにする制約 const_limit = [ penalty(q[i][r]) for i, x in limitation.items() for r in range(num_registers) if r not in x ] constraints = sum(const_onehot) if len(const_spill) != 0: constraints += sum(const_spill) if len(const_limit) != 0: constraints += sum(const_limit) return {"qubits": q, "model": BinaryQuadraticModel(constraints)}
def energy(self, c_weight: float): """ハミルトニアン Returns: [type]: -H_A + H_B + λH_C """ return BinaryQuadraticModel(-self.room_total_satisfaction() + self.room_variance_satisfaction() + c_weight * self.time_constraint())
def solve(self): q = gen_symbols(BinaryPoly, *self.board.get_size(), len(self.pieces), 8) # 制約(a) 重複する置き方のピースは除外する for y in range(self.board.get_size()[0]): for x in range(self.board.get_size()[1]): for i in range(len(self.pieces)): for j in range(self.pieces[i].placement_count, 8): q[y][x][i][j] = BinaryPoly(0) # 制約(b) ピースはボードから外に出ない for y in range(self.board.get_size()[0]): for x in range(self.board.get_size()[1]): for i in range(len(self.pieces)): for j in range(self.pieces[i].placement_count): if len(self.pieces[i].get_blocks(j, (x, y)) - self.board.get_blocks()) > 0: q[y][x][i][j] = BinaryPoly(0) # 制約(c) ピース同士は重ならずボードを全て埋める s = dict() for b in self.board.get_blocks(): s[b] = BinaryPoly() for y in range(self.board.get_size()[0]): for x in range(self.board.get_size()[1]): for i in range(len(self.pieces)): for j in range(self.pieces[i].placement_count): for p in self.pieces[i].get_blocks( j, (x, y)) & self.board.get_blocks(): s[p] += q[y][x][i][j] board_constraints = [equal_to(q, 1) for q in s.values()] # 制約(d) 全てのピースは一度ずつ使われる piece_constraints = [ equal_to( sum(q[y][x][i][j] for y in range(self.board.get_size()[0]) for x in range(self.board.get_size()[1]) for j in range(8)), 1) for i in range(len(self.pieces)) ] constraints = (sum(board_constraints) + sum(piece_constraints)) solver = Solver(self.client) model = BinaryQuadraticModel(constraints) result = solver.solve(model) if len(result) == 0: raise RuntimeError("Any one of constaraints is not satisfied.") solution = result[0] values = solution.values q_values = decode_solution(q, values) Visualizer().visualize(self.pieces, self.board, q_values)
def by_amplify(list_dependent_variables, num_registers): num_variables = len(list_dependent_variables) q = gen_symbols(BinaryPoly, num_variables, num_registers) # 各変数を1つのレジスタに割り当てるOne-het制約 const_onehot = [ equal_to(sum_poly([q[i][r] for r in range(num_registers)]), 1) for i in range(num_variables) ] # レジスタスピルを減らすために,依存関係のある変数同士が同一のレジスタに割り当てられない制約 const_spill = [ penalty(q[i][r] * q[j][r]) for i in range(num_variables) for j in list_dependent_variables[i] if i < j for r in range(num_registers) ] constraints = sum(const_onehot) + sum(const_spill) return {"qubits": q, "model": BinaryQuadraticModel(constraints)}
def solve(self, c_weight: float = 3, timeout: int = 1000, num_unit_step: int = 10) -> Setlist: """ Args: c_weight (float): 時間制約の強さ timeout (int, optional): Fixstars AE のタイムアウト[ms] (デフォルト: 10000) num_unit_step (int, optional): Fixstars AE のステップ数 (デフォルト: 10) Returns: Setlist: セットリスト """ self.q = gen_symbols(BinaryPoly, self.num_tracks) energy_function = self.energy(c_weight) model = BinaryQuadraticModel(energy_function) fixstars_client = FixstarsClient() fixstars_client.token = os.environ.get("FIXSTARS_API_TOKEN") fixstars_client.parameters.timeout = timeout fixstars_client.parameters.num_unit_steps = num_unit_step amplify_solver = Solver(fixstars_client) amplify_solver.filter_solution = False result = amplify_solver.solve(model) q_values = decode_solution(self.q, result[0].values) tracks = [self.candidates[i] for i, v in enumerate(q_values) if v == 1] total_time = 0 user_scores = np.zeros(self.num_users) for track in tracks: user_scores += np.array(track.p) total_time += track.duration_ms return Setlist(tracks=tracks, scores=user_scores.tolist(), score_sum=user_scores.sum(), score_avg=user_scores.mean(), score_var=user_scores.var(), total_time=total_time)
reg_constraints = [ equal_to(sum_poly([q[i][c] for c in range(num_colors)]), 1) for i in range(num_region) ] # 隣接する領域間の制約 adj_constraints = [ # 都道府県コードと配列インデックスは1ずれてるので注意 penalty(q[i][c] * q[j - 1][c]) for i in range(num_region) for j in jm.adjacent(i + 1) # j: 隣接している都道府県コード if i + 1 < j for c in range(num_colors) ] constraints = sum(reg_constraints) + sum(adj_constraints) model = BinaryQuadraticModel(constraints) result = solver.solve(model) if len(result) == 0: raise RuntimeError("Any one of constraints is not satisfied.") values = result[0].values q_values = decode_solution(q, values, 1) color_indices = np.where(np.array(q_values) == 1)[1] color_map = { jm.pref_names[i + 1]: colors[color_indices[i]] for i in range(len(color_indices)) } plt.rcParams["figure.figsize"] = 6, 6 plt.imshow(jm.picture(color_map))
def quantum_solver_approx(N, M, query): # solve with Amplify (approximate version) q = gen_symbols(BinaryPoly, M, N, N) # represent the solution ########## constraints ########## # each layer doesn't have 2+ same values one_hot_constraints_layer = [ # m -> layer # n -> qubit # v -> value of qubit equal_to(sum(q[m][n][v] for n in range(N)), 1) for m in range(M) for v in range(N) ] # each qubit doesn't have 2+ values one_hot_constraints_num = [ # m -> layer # n -> qubit # v -> value of qubit equal_to(sum(q[m][n][v] for v in range(N)), 1) for m in range(M) for n in range(N) ] # every CX gate must be applied for 2 adjacent qubits CXgate_constraints = [] for m in range(M): for g0 in range(0, len(query[m]), 2): v0, v1 = query[m][g0], query[m][g0 + 1] # v0 and v1 must be adjacent each other for i in range(N): for j in range(i + 2, N): CXgate_constraints.append( penalty(q[m][i][v0] * q[m][j][v1])) CXgate_constraints.append( penalty(q[m][i][v1] * q[m][j][v0])) constraints = (sum(one_hot_constraints_layer) + sum(one_hot_constraints_num) + sum(CXgate_constraints)) cost = sum_poly( M - 1, lambda m: sum_poly( N, lambda i: sum_poly( N, lambda j: sum_poly(N, lambda v: q[m][i][v] * q[m + 1][j][v]) * ((N - 1) * (i + j) - 2 * i * j) / N))) ########## solve ########## solver = Solver(client) model = BinaryQuadraticModel(constraints * constraintWeight + cost) result = solver.solve(model) if len(result) == 0: raise RuntimeError("Any one of constraints is not satisfied.") values = result[0].values q_values = decode_solution(q, values, 1) # print(q_values_main) ########## decode the result into string ########## ans = [[-1 for n in range(N)] for m in range(M)] for m in range(M): for n in range(N): for v in range(N): if (q_values[m][n][v] > 0.5): ans[m][n] = v cost = 0 for m in range(M - 1): cost += calcCost(ans[m], ans[m + 1]) return cost, ans
def quantum_solver_strict(N, M, query): # solve by Amplify (strict version) q_all = gen_symbols(BinaryPoly, M * N * N + (M - 1) * N * N * N + (M - 1) * N * N) q = q_all[:M * N * N] # represent the solution q_sub = q_all[M * N * N:M * N * N + (M - 1) * N * N * N] # q_sub[m][i][j][v] = q[m][i][v] * q[m+1][j][v] q_C_matrix = q_all[ M * N * N + (M - 1) * N * N * N:] # q_C_matrix[m][i][j] = sum(q_sub[m][i][j][v] for v) ########## constraints ########## # each layer doesn't have 2+ same values one_hot_constraints_layer = [ # m -> layer # n -> physical qubit # v -> logical qubit equal_to(sum(q[(m * N + n) * N + v] for n in range(N)), 1) for m in range(M) for v in range(N) ] # each qubit doesn't have 2+ values one_hot_constraints_num = [ # m -> layer # n -> physical qubit # v -> logical qubit equal_to(sum(q[(m * N + n) * N + v] for v in range(N)), 1) for m in range(M) for n in range(N) ] # every CX gate must be applied for 2 adjacent qubits CXgate_constraints = [] for m in range(M): for g0 in range(0, len(query[m]), 2): v0, v1 = query[m][g0], query[m][g0 + 1] # v0 and v1 must be adjacent each other for i in range(N): for j in range(i + 2, N): CXgate_constraints.append( penalty(q[(m * N + i) * N + v0] * q[(m * N + j) * N + v1])) CXgate_constraints.append( penalty(q[(m * N + i) * N + v1] * q[(m * N + j) * N + v0])) # q_sub[m][i][j][v] = q[m][i][v] * q[m+1][j][v] sub_gate_constraints = [] for _idx in range((M - 1) * N**3): idx = _idx m = idx // (N**3) idx %= N**3 i = idx // (N**2) idx %= N**2 j = idx // N idx %= N v = idx sub_gate_constraints.append( penalty(3 * q_sub[((m * N + i) * N + j) * N + v] + q[(m * N + i) * N + v] * q[((m + 1) * N + j) * N + v] - 2 * q_sub[((m * N + i) * N + j) * N + v] * (q[(m * N + i) * N + v] + q[((m + 1) * N + j) * N + v]))) # q_C_matrix[m][i][j] = sum(q_sub[m][i][j][v] for v) C_matrix_sum_constraints = [] for _idx in range((M - 1) * N**2): idx = _idx m = idx // (N**2) idx %= N**2 i = idx // N idx %= N j = idx C_matrix_sum_constraints.append( equal_to( q_C_matrix[(m * N + i) * N + j] - sum(q_sub[((m * N + i) * N + j) * N + v] for v in range(N)), 0)) constraints = (sum(one_hot_constraints_layer) + sum(one_hot_constraints_num) + sum(CXgate_constraints) + sum(sub_gate_constraints) + sum(C_matrix_sum_constraints)) cost = [] for m in range(M - 1): for i1 in range(N): for j1 in range(i1): # i1 > j1 for i2 in range(N): for j2 in range(i2 + 1, N): # i2 < j2 cost.append(q_C_matrix[(m * N + i1) * N + j1] * q_C_matrix[(m * N + i2) * N + j2]) for j1 in range(i1 + 1, N): # i1 < j1 for i2 in range(N): for j2 in range(i2): # i2 > j2 cost.append(q_C_matrix[(m * N + i1) * N + j1] * q_C_matrix[(m * N + i2) * N + j2]) # print(constraints) # print(cost) ########## solve ########## solver = Solver(client) model = BinaryQuadraticModel(constraints * constraintWeight + sum(cost)) result = solver.solve(model) if len(result) == 0: raise RuntimeError("Any one of constraints is not satisfied.") values = result[0].values q_values = decode_solution(q_all, values, 1) # print(q_values_main) ########## decode the result into string ########## ans = [[-1 for n in range(N)] for m in range(M)] for m in range(M): for n in range(N): for v in range(N): if (q_values[(m * N + n) * N + v] > 0.5): ans[m][n] = v cost = 0 for m in range(M - 1): cost += calcCost(ans[m], ans[m + 1]) return cost, ans
) from amplify.client import FixstarsClient # print(cost) # print(constraints) # print(type(cost)) # print(type(constraints)) # f = gen_symbols(BinaryPoly, 5) # print(f) # for i in range(5): # f[i] = 1 # print(sum(f)) # 0, 1 の乱数列の生成 # print([random.randint(0,1) for i in range(10)]) f = BinaryPoly({ (0, 1, 2, 3): 2, (0, 3): -2, (0, 1): 1, (0): 1, (1): 1, (2): 1 }, -1) model = BinaryQuadraticModel(f) print(model.input_poly) print(model.logical_poly)