def model(cfg, data, label): w = gen_symbols(IsingPoly, cfg.dataset.features, cfg.model.length_weight) f = forward(data, label, w, cfg) q_result = decode_solution(w, solve_model(f)) q_result = np.vectorize(is_int)(q_result) return q_result
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 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 make_hamiltonian(d, feed_dict): # set the number of cities N = len(d) # set hyperparameters lambda_1 = feed_dict['h1'] lambda_2 = feed_dict['h2'] # make variables x = gen_symbols(BinaryPoly, N, N) # set One-hot constraint for time h1 = [equal_to(sum_poly([x[n][i] for n in range(N)]), 1) for i in range(N)] # set One-hot constraint for city h2 = [equal_to(sum_poly([x[n][i] for i in range(N)]), 1) for n in range(N)] # compute the total of constraints const = lambda_1 * sum(h1) + lambda_2 * sum(h2) # set objective function obj = sum_poly(N, lambda n: sum_poly(N, lambda i: sum_poly(N, lambda j: d[i][j]*x[n][i]*x[(n+1)%N][j]), ), ) # compute model model = obj + const return x, model
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)
def make_hamiltonian(type_matrix, weak_matrix, resist_matrix, enemies, num_party, feed_dict): # set the number of types N = len(type_matrix) # set the number of enemies M = len(enemies) # set hyperparameters lambda_1 = feed_dict['h1'] lambda_2 = feed_dict['h2'] lambda_3 = feed_dict['h3'] # make variables x = gen_symbols(BinaryPoly, num_party, N) # set one-hot constraint for types h1 = [equal_to(sum_poly([x[i][j] for j in range(N)]), 1) for i in range(num_party)] # set weak constraint h2 = [less_equal(sum_poly(N, lambda j: sum_poly(num_party, lambda l: sum_poly(N, lambda k: enemies[i][j]*weak_matrix[j][k]*x[l][k]))), 2) for i in range(M)] # set resist constraint h3 = [greater_equal(sum_poly(N, lambda j: sum_poly(num_party, lambda l: sum_poly(N, lambda k: enemies[i][j]*resist_matrix[j][k]*x[l][k]))), 1) for i in range(M)] # compute the total of constraints const = lambda_1 * sum(h1) + lambda_2 * sum(h2) + lambda_3 * sum(h3) # set objective function obj = sum_poly(num_party, lambda i: sum_poly(N, lambda j: sum_poly(N, lambda k: sum_poly(M, lambda l: x[i][j]*type_matrix[j][k]*enemies[l][k])))) # compute model model = - obj + const return x, model
pa_diff_each = [] for j in range(len(pol_data[i][2])): if j < len(pol_data[i][2]) - 1: angle_diff = pol_data[i][2][j + 1][2] - pol_data[i][2][j][2] pa_diff_each.append([pol_data[i][2][j][0], angle_diff]) else: angle_diff = pol_data[i][2][0][2] - pol_data[i][2][j][2] pa_diff_each.append([pol_data[i][2][j][0], angle_diff]) pa_diff_data.append([pol_data[i][0], pol_data[i][1], pa_diff_each]) # テンプレートとして持っているデータの個数をバイナリ変数の数とする。 # 1のとき、その角度パラメータである。0のときその角度パラメータではないとする。 q = gen_symbols(BinaryPoly, len(pa_diff_data)) # onehot条件: 当てはまる角度パラメータは1つだけ const_onehot = (sum_poly(q) - 1)**2 # 目的関数: 各回転位相での偏光角の違いを小さくするためのもの obj_pa = 0.0 coef = 1.0 / 180.0 for j in range(len(pa_test)): obj_pa_j = pa_test[j][1] for i in range(len(pa_data)): obj_pa_j -= pa_data[i][2][j][1] * q[i] obj_pa += coef**2 * obj_pa_j**2
from amplify.client import FixstarsClient # クライアントの設定 client = FixstarsClient() # Fixstars Optigan client.parameters.timeout = 1000 # タイムアウト1秒 client.token = "i5G6Ei3DKlGv2n6hsWBSBzWrmffLN4vn" #20210011まで有効 client.parameters.outputs.duplicate = True # 同じエネルギー値の解を列挙するオプション(解が複数個あるため) # 数の集合Aに対応する数のリスト A = [2, 10, 3, 8, 5, 7, 9, 5, 3, 2] # len(A): 変数の数 n = len(A) # Binary 変数を生成 q = gen_symbols(BinaryPoly, n) # 目的関数の構築 f = BinaryPoly() for i in range(n): f += (2 * q[i] - 1) * A[i] f = f ** 2 # ソルバーの構築 solver = Solver(client) # ソルバーに使用するクライアントを設定 # 問題を入力してマシンを実行 result = solver.solve(f) # 問題を入力してマシンを実行
from amplify import BinaryPoly, gen_symbols, Solver, decode_solution from amplify.client import FixstarsClient # クライアントの設定 client = FixstarsClient() # Fixstars Optigan client.parameters.timeout = 1000 # タイムアウト1秒 client.token = "i5G6Ei3DKlGv2n6hsWBSBzWrmffLN4vn" #20210011まで有効 # client.parameters.outputs.duplicate = True # 同じエネルギー値の解を列挙するオプション(解が複数個ある場合) # 4要素の1次元配列のバイナリ変数 q_1d = gen_symbols(BinaryPoly, 4) # 3x2 の 2次元配列型のバイナリ変数 q_2d = gen_symbols(BinaryPoly, 3, 2) # 変数インデックスが10から始まる 3x2 の 2次元配列型のバイナリ変数 q_2d_2 = gen_symbols(BinaryPoly, 10, (3, 2)) print(f"q_1d = {q_1d}") print(f"q_2d = {q_2d}") print(f"q_2d_2 = {q_2d_2}") q = gen_symbols(BinaryPoly, 4) # q_0 * q_1 + q_2 f0 = q[0] * q[1] + q[2] # q_1 + q_3 + 1 f1 = q[1] + q[3] + 1 # (q_0 * q_1 + q_2) + (q_1 + q_3 + 1)
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
import japanmap as jm import matplotlib.pyplot as plt client = FixstarsClient() client.token = "i5G6Ei3DKlGv2n6hsWBSBzWrmffLN4vn" #20210011まで有効 client.parameters.timeout = 5000 # タイムアウト5秒 solver = Solver(client) # 四色の定義 colors = ["red", "green", "blue", "yellow"] num_colors = len(colors) num_region = len(jm.pref_names) - 1 # 都道府県数を取得 # 都道府県数 x 色数 の変数を作成 q = gen_symbols(BinaryPoly, num_region, num_colors) # 各領域に対する制約 # 一つの領域に一色のみ(one-hot) # sum_{c=0}^{C-1} q_{i,c} = 1 for all i 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)
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
GRAND_MENU_PRICES = [] # 料理のカロリーリスト GRAND_MENU_CALORIES = [] # 料理数 GRAND_MENU_NUM = len(GRAND_MENU) # それぞれのリストに値を格納 for i in range(GRAND_MENU_NUM): GRAND_MENU_NAMES.append(GRAND_MENU[i]["name"]) GRAND_MENU_PRICES.append(GRAND_MENU[i]["price"]) GRAND_MENU_CALORIES.append(GRAND_MENU[i]["calorie"]) # 料理の数だけバイナリ変数を生成 q = gen_symbols(BinaryPoly, GRAND_MENU_NUM) # 目指す合計金額 TOTAL_AMOUNT = 1000 # 目的関数の構築 f = BinaryPoly() for i in range(GRAND_MENU_NUM): f += GRAND_MENU_PRICES[i] * q[i] f = (TOTAL_AMOUNT - f)**2 # クライアントの設定 client = FixstarsClient() client.parameters.timeout = 1000 # タイムアウト1秒
from amplify import BinaryPoly, Solver, sum_poly, gen_symbols, decode_solution from amplify.constraint import clamp, equal_to, greater_equal, less_equal, penalty from amplify.client import FixstarsClient # クライアントの設定 client = FixstarsClient() # Fixstars Optigan client.parameters.timeout = 1000 # タイムアウト1秒 client.token = "i5G6Ei3DKlGv2n6hsWBSBzWrmffLN4vn" #20210011まで有効 client.parameters.outputs.duplicate = True # 同じエネルギー値の解を列挙するオプション client.parameters.outputs.num_outputs = 0 # 見つかったすべての解を出力 # ソルバーの構築 solver = Solver(client) # ソルバーに使用するクライアントを設定 # バイナリ変数:要素数2 q = gen_symbols(BinaryPoly, 2) ########################################################### # NAND制約を与える多項式 g_NAND = q[0] * q[1] # NAND制約をペナルティ制約条件に変換 p_NAND = penalty(g_NAND) print("NAND") print(f"p_NAND = {p_NAND}") # 制約条件を満たす解を求める result = solver.solve(p_NAND) for sol in result: energy = sol.energy
from amplify.client import FixstarsClient # クライアントの設定 client = FixstarsClient() # Fixstars Optigan client.parameters.timeout = 1000 # タイムアウト1秒 client.token = "i5G6Ei3DKlGv2n6hsWBSBzWrmffLN4vn" #20210011まで有効 client.parameters.outputs.duplicate = True # 同じエネルギー値の解を列挙するオプション(解が複数個ある場合) # 数の集合Aに対応する数のリスト A = [2, 10, 3, 8, 5, 7, 9, 5, 3, 2] # len(A): 変数の数 n = len(A) # イジング変数を生成 s = gen_symbols(IsingPoly, n) # 目的関数の構築: イジング f = IsingPoly() for i in range(n): f += s[i] * A[i] f = f ** 2 # ソルバーの構築 solver = Solver(client) # 問題を入力してマシンを実行 result = solver.solve(f)
# 研究室教員数 nteachers = [1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 1] assert nlab == len(nteachers), "研究室数と教員数配列の長さが違う" # 研究室学生数 nstudents = [4, 5, 4, 3, 3, 2, 4, 4, 4, 4, 5, 3, 4, 3, 3] assert nlab == len(nstudents), "研究室数と学生数配列の長さが違う" # グループ名 grps = ["CS1", "CS2", "CS3", "CS4"] ngrp = len(grps) # グループ数 ################################################################################## # QUBO変数の生成: nlab x ngrp q = gen_symbols(BinaryPoly, nlab, ngrp) # グループ内の教員数 T = [ sum_poly([q[i][j] * nteachers[i] for i in range(nlab)]) for j in range(ngrp) ] # グループ内の学生数 S = [ sum_poly([q[i][j] * nstudents[i] for i in range(nlab)]) for j in range(ngrp) ] ################################################################################## # コスト関数:各グループの学生数、教員数が等しいか?
from amplify import BinaryPoly, gen_symbols, sum_poly, Solver from amplify.constraint import greater_equal from amplify.client import HitachiClient from secret import get_token import utils import time # 問題サイズ N=2,4,6,8,10,12,14,16 で実験 for N in range(2, 16 + 1, 2): # QUBO変数の2次元配列(正方格子グラフに対応) q = gen_symbols(BinaryPoly, N, N) # コスト関数(w_b で調整) cost_function = sum([sum_poly(q[i]) for i in range(N)]) # 制約(w_a で調整) constraint_x = sum([ greater_equal(q[i][j] + q[i + 1][j], 1) for i in range(N - 1) for j in range(N) ]) constraint_y = sum([ greater_equal(q[i][j] + q[i][j + 1], 1) for i in range(N) for j in range(N - 1) ]) constraint = constraint_x + constraint_y # クライアント設定 client = HitachiClient() client.token = get_token()
def find_feasible_solution(self): """find a feasible locations with makespan, found -> set self.used_edges """ # create variables q = [] index = 0 for t in range(self.makespan): q.append([]) for v in range(self.field["size"]): l = len(self.field["adj"][v])+1 # +1 -> stay at the current location q[-1].append( amplify.gen_symbols( amplify.BinaryPoly, index, (1, l) ) ) index += l # set starts constraints_starts = [ equal_to(sum_poly( q[0][v][0] ), 1) # q[timestep][node][0] for v in self.instance["starts"] ] for v in range(self.field["size"]): if v in self.instance["starts"]: continue # other locations for i in range(len(q[0][v][0])): q[0][v][0][i] = amplify.BinaryPoly(0) # set goals constraints_goals = [ equal_to(sum_poly([ q[-1][u][0][ self.field["adj"][u].index(v) ] for u in self.field["adj"][v] ] + [ q[-1][v][0][ len(self.field["adj"][v]) ] ]), 1) for v in self.instance["goals"] ] for v in range(self.field["size"]): # other locations for i in range(len(self.field["adj"][v])): if self.field["adj"][v][i] not in self.instance["goals"]: q[-1][v][0][i] = amplify.BinaryPoly(0) if v not in self.instance["goals"]: q[-1][v][0][-1] = amplify.BinaryPoly(0) # upper bound, in constraints_in = [ less_equal(sum_poly([ q[t][u][0][ self.field["adj"][u].index(v) ] for u in self.field["adj"][v] ] + [ q[t][v][0][ len(self.field["adj"][v]) ] ]), 1) for v, t in product(range(self.field["size"]), range(0, self.makespan-1)) ] # upper bound, out constraints_out = [ less_equal(sum_poly( q[t][v][0] ), 1) for v, t in product(range(self.field["size"]), range(1, self.makespan)) ] # continuity constraints_continuity = [ equal_to(sum_poly([ q[t][u][0][ self.field["adj"][u].index(v) ] for u in self.field["adj"][v] ] + [ q[t][v][0][ len(self.field["adj"][v]) ] ]) - sum_poly( q[t+1][v][0] ), 0) for v, t in product(range(self.field["size"]), range(0, self.makespan-1)) ] # branching for v in range(self.field["size"]): if not self.field["body"][v]: continue # unreachable vertexes from starts for t in range(0, min(self.DIST_TABLE_FROM_STARTS[v], self.makespan)): for i in range(len(q[t][v][0])): q[t][v][0][i] = amplify.BinaryPoly(0) # unreachable vertexes to goals for t in range(max(self.makespan - self.DIST_TABLE_FROM_GOALS[v] + 1, 0), self.makespan): for i in range(len(q[t][v][0])): q[t][v][0][i] = amplify.BinaryPoly(0) # set occupied vertex for v in range(self.field["size"]): if self.field["body"][v]: continue for t in range(0, self.makespan): q[t][v][0][-1] = amplify.BinaryPoly(0) # create model model = sum(constraints_starts) model += sum(constraints_goals) if len(constraints_in) > 0: model += sum(constraints_in) if len(constraints_out) > 0: model += sum(constraints_out) if len(constraints_continuity) > 0: model += sum(constraints_continuity) # setup client client = FixstarsClient() client.token = os.environ['TOKEN'] client.parameters.timeout = self.timeout # solve solver = amplify.Solver(client) result = solver.solve(model) if len(result) > 0: self.used_edges = amplify.decode_solution(q, result[0].values)