SQOA Solver — Qiskit Function від JIJ

Дивись довідник API.

примітка

Qiskit Functions — це експериментальна функція, доступна лише користувачам IBM Quantum® Premium Plan, Flex Plan і On-Prem (через IBM Quantum Platform API) Plan. Вони мають статус попереднього випуску та можуть змінюватися.

Огляд

За допомогою SQOA Solver від JIJ ти можеш розв'язувати великі комбінаторні задачі оптимізації на квантових комп'ютерах IBM®. Розв'язувач базується на алгоритмі квантової оптимізації на основі вибірки з квантовою релаксацією (Sampling-based Quantum Optimization Algorithm with Quantum Relaxation, SQOA-QR) [1]. На відміну від квантових алгоритмів, що використовують відображення «один до одного» між класичними змінними рішення та кубітами, SQOA Solver може обробляти задачі оптимізації з більшою кількістю змінних, ніж кількість кубітів, доступних на сучасних квантових пристроях. Його дизайн на основі вибірки також робить його менш чутливим до фізичного шуму сучасного квантового обладнання. Разом ці риси роблять SQOA Solver добре придатним для задач оптимізації на цьому етапі розвитку квантових обчислень.

Розв'язувач обробляє задачі квадратичної безумовної бінарної оптимізації (QUBO), задані як класичне математичне формулювання, і автоматично відображає класичне формулювання на квантове середовище. Ти також можеш перетворювати задачі з обмеженнями на задачі без обмежень за допомогою методу штрафів.

У наступних розділах описано робочий процес розв'язувача, результати бенчмарків і наскрізні приклади, що моделюють задачі за допомогою qiskit-addon-opt-mapper і, за бажанням, Open Mathematical prograMming eXchange (OMMX). OMMX — це відкритий формат даних і SDK, що спрощує обмін задачами оптимізації між програмними інструментами.

Опис

SQOA Solver реалізує алгоритм Sampling-based Quantum Optimization Algorithm with Quantum Relaxation (SQOA-QR) і оточує його класичною попередньою та подальшою обробкою. У цьому розділі пояснюється фреймворк SQOA і чим він відрізняється від Quantum Approximate Optimization Algorithm (QAOA).

На наступному рисунку показано схему робочого процесу SQOA Solver.

Фреймворк SQOA

SQOA — це фреймворк на основі вибірки для комбінаторної оптимізації [1]. Він поєднує дві техніки: Quantum Random Access Optimization (QRAO) [2], яка кодує задачу в квантовій релаксації, і діагоналізацію на основі вибірки (sample-based quantum diagonalization, SQD) [3], відому також як quantum-selected configuration interaction (QSCI) [4], яка використовує квантовий комп'ютер лише для вибірки бітових рядків, а стан з найнижчою енергією знаходить на класичному комп'ютері. SQOA є фреймворком у тому сенсі, що фіксує це поєднання, але залишає подробиці кожній реалізації, наприклад, як змінні призначаються кубітам і які схеми генерують вибірки.

• Квантова релаксація з QRAO. QAOA та інші підходи на основі моделі Ізинга представляють кожну бінарну змінну оператором $Z$ її кубіта. QRAO також використовує оператори $X$ і $Y$. За допомогою квантового коду випадкового доступу (QRAC) (3,1) до трьох бінарних змінних ділять один кубіт, і кожна змінна представлена іншим оператором Паулі.

  Тоді QUBO стає релаксованим гамільтоніаном, якому потрібно менше кубітів, ніж гамільтоніану Ізинга. Змінні, які взаємодіють у QUBO, мають бути розміщені на різних кубітах. Якби вони ділили кубіт, добуток їхніх операторів Паулі зводився б до одного оператора на цьому кубіті (наприклад, $XY = iZ$), і релаксований гамільтоніан більше не представляв би їхню взаємодію.

  Тому призначення змінних кубітам визначає і кількість кубітів, і якість релаксації, а SQOA Solver проєктує це призначення під час попередньої обробки.

• Діагоналізація на основі вибірки (SQD). Спершу квантовий комп'ютер готує квантовий стан, що перекривається зі станами з низькою енергією релаксованого гамільтоніана, а потім робить із нього вибірку бітових рядків. Класичний комп'ютер проєктує релаксований гамільтоніан на підпростір, натягнутий на вибрані бітові рядки, і діагоналізує його, щоб наблизити основний стан.

  Оскільки релаксований гамільтоніан недіагональний, діагоналізація об'єднує вибрані бітові рядки в суперпозицію. З діагональним гамільтоніаном Ізинга кожен бітовий рядок уже є власним станом, і діагоналізація лише обирала б найкращу вибірку. Такий самий підхід застосовувався до великомасштабних задач квантової хімії.

Наближений основний стан, отриманий за допомогою SQD, не відповідає безпосередньо класичному розв'язку вихідної задачі, тому класичний розв'язок потрібно з нього декодувати. Оскільки цей стан обчислюється на класичному комп'ютері, декодування, яке називається округленням, є класичною подальшою обробкою. SQOA Solver використовує техніки декодування, розроблені для евристичного отримання кращих класичних розв'язків.

У наступній таблиці SQOA порівнюється з QAOA — поширеним варіаційним підходом до того самого класу задач.

	QAOA	SQOA
Кубіти для $n$ бінарних змінних	$n$	Один кубіт містить до трьох змінних. Точна кількість залежить від структури задачі
Використання QPU	Багаторазово оцінює енергію параметризованих схем усередині класичного циклу оптимізації	Лише робить вибірку бітових рядків. На QPU не навчаються жодні параметри схем
Від вибірок до розв'язку	Обирає найкращий виміряний бітовий рядок	Діагоналізує релаксований гамільтоніан у вибраному підпросторі на класичному комп'ютері та округлює отриманий стан

Навколо SQOA-QR SQOA Solver додає класичну обробку. Його попередня обробка фіксує змінні, чиї оптимальні значення можна визначити заздалегідь, і проєктує призначення змінних кубітам. Його подальша обробка уточнює округлений розв'язок локальним пошуком, який можна вимкнути за допомогою postprocessing_level=0.

Бенчмарки

Застереження

Продуктивність може залежати як від екземпляра задачі, так і від подальших кроків обробки. У деяких випадках класичні вибірки та квантово згенеровані вибірки можуть досягати подібної якості кінцевого розв'язку після еквівалентної подальшої обробки. Тому оцінювання має враховувати весь робочий процес оптимізації.

Наведені нижче метрики бенчмарків дають загальне уявлення про якість розв'язку, стиснення кубітів і час виконання для вибраних розмірів і структур задач. У таблиці наведено добірку екземплярів задачі про максимальну незалежну множину з Quantum Optimization Benchmarking Library (QOBLIB) і два 3-регулярні екземпляри MaxCut. Ти можеш завантажити екземпляри QOBLIB як об'єкти ommx.v1.Instance разом з їхніми оптимальними розв'язками за допомогою пакета ommx-quantum-benchmarks.

Кожен екземпляр запускали 10 разів на процесорі IBM Heron r2. Number of qubits рахує кубіти, фактично використані на апаратному забезпеченні після попередньої обробки та кодування QRAC. Коефіцієнт стиснення залежить від екземпляра. Approximation ratio (AR) показує якість найкращого розв'язку, знайденого за 10 запусків:

$$\mathrm{AR} = \frac{C_{\textrm{best}}}{C_{\textrm{opt}}},$$

де $C_{\textrm{best}}$ — найкраще знайдене значення цільової функції, а $C_{\textrm{opt}}$ — відоме оптимальне значення цільової функції. Усі екземпляри є задачами максимізації з додатним оптимальним значенням, тому AR не перевищує 100%, а 100% у стовпці Approximation ratio означає, що розв'язувач знайшов оптимальний розв'язок. Total time — це середній сумарний час QPU і CPU за один запуск. QPU time — це середнє використання IBM Quantum Compute за один запуск.

Екземпляр	Кількість змінних	Кількість кубітів	Коефіцієнт апроксимації	Загальний час (секунди)	Час QPU (секунди)
maxcut_384_nodes	384	129	98.5%	62.1	12.0
gen200_p0-9_44	200	67	100%	38.0	12.0
es60fst02	186	42	100%	24.7	12.0
es60fst04	162	29	100%	17.9	12.0
maxcut_150_nodes	150	51	100%	23.1	12.0
sloane_1dc_128	128	37	93.8%	19.1	12.0
sloane_2dc_128	128	8	100%	12.3	11.5
C125-9	125	43	100%	22.3	12.0
es60fst01	123	12	100%	13.6	12.0
es60fst03	113	26	100%	14.9	12.0
sloane_1dc_64	64	16	100%	13.4	11.9
chesapeake	39	13	100%	13.1	12.0
football	35	6	100%	12.5	12.0
karate	34	2	100%	6.2	6.0
ibm32	32	11	100%	12.9	12.0
farm	17	4	100%	8.5	8.0

Початок роботи

Інформацію про доступ до цієї Qiskit Function знайдеш у Qiskit Functions Catalog.

У цьому розділі показано, як автентифікуватися та завантажити функцію, а також як підготувати задачу у форматі словника, який приймає SQOA Solver, за допомогою OptimizationProblem з qiskit-addon-opt-mapper. Наступні приклади запускають функцію та зчитують результат.

Автентифікація та завантаження функції

Спершу автентифікуйся за допомогою свого ключа API IBM Quantum. (Наведений далі код припускає, що ти вже зберіг свій обліковий запис у локальному середовищі.) Потім створи клієнт каталогу так:

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"jijmodeling": "jijmodeling", "networkx": "networkx", "ommx": "ommx", "qiskit_addon_opt_mapper": "qiskit-addon-opt-mapper", "qiskit_ibm_catalog": "qiskit-ibm-catalog"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# verify that you have access to the function
catalog.list()

[QiskitFunction(jij/sqoa-solver)]

solver = catalog.load("jij/sqoa-solver")

Підготовка вхідних даних за допомогою qiskit-addon-opt-mapper

У цьому посібнику задачі моделюються за допомогою класу OptimizationProblem з qiskit-addon-opt-mapper. SQOA Solver приймає задачу QUBO як словник коефіцієнтів у форматі кортеж-рядок, який використовують оптимізаційні функції IBM, тому кожен приклад у цьому посібнику дотримується того самого шаблону підготовки на стороні клієнта:

1. Напиши модель. Створи OptimizationProblem, додай бінарні змінні рішення та задай цільову функцію й будь-які обмеження.

2. Перетвори на QUBO. Перетвори задачу за допомогою OptimizationProblemToQubo, який додає будь-які обмеження до цільової функції як штрафні доданки та повертає еквівалентну задачу мінімізації без обмежень.

3. Перетвори на словник. Передай QUBO допоміжній функції to_problem_dict(), визначеній у наступному розділі, і передай результат до solver.run() як problem разом із variable_type="binary".

SQOA Solver завжди мінімізує задачу у вигляді словника, що відповідає задачі мінімізації, яку повертає OptimizationProblemToQubo. Тому для задачі максимізації повернуте objective_value є від'ємним значенням вихідної цільової функції. Щоб прочитати результат в термінах вихідної задачі, обчисли повернуте призначення за допомогою OptimizationProblem, як показано в прикладах. Подробиці формату словника дивись у розділі Accepted problem formats довідника API.

# %pip install qiskit-addon-opt-mapper

Визнач наведену нижче допоміжну функцію один раз і використовуй її в кожному прикладі. Вона перетворює QUBO, яке повертає OptimizationProblemToQubo, на формат словника. Ключі використовують індекси змінних QUBO, тому ключі розв'язку x_0, x_1 і так далі в результаті відповідають цим індексам. Кожна змінна отримує лінійний запис, навіть із нульовим коефіцієнтом, щоб повернутий розв'язок охоплював усі змінні.

from qiskit_addon_opt_mapper import OptimizationProblem
from qiskit_addon_opt_mapper.converters import OptimizationProblemToQubo

def to_problem_dict(qubo: OptimizationProblem) -> dict[str, float]:
    """Convert a QUBO from OptimizationProblemToQubo to the SQOA Solver dictionary format."""
    objective = qubo.objective
    payload = {"()": objective.constant}
    # Keep every variable in the problem, even with a zero linear coefficient.
    payload.update({f"({i},)": 0.0 for i in range(qubo.get_num_vars())})
    for i, coefficient in objective.linear.to_dict().items():
        payload[f"({i},)"] += coefficient
    for (i, j), coefficient in objective.quadratic.to_dict().items():
        # Fold a binary diagonal term x_i * x_i = x_i into the linear term.
        key = f"({i},)" if i == j else f"({i}, {j})"
        payload[key] = payload.get(key, 0.0) + coefficient
    return {key: float(value) for key, value in payload.items()}

Приклад 1: MaxCut на 3-регулярному графі

Багато графових задач, як-от MaxCut, є NP-складними та природними кандидатами для квантової оптимізації. Встанови networkx як додаткову залежність, щоб запустити цей приклад:

# %pip install networkx

1. Напиши модель

Призначи бінарну змінну $x_v \in \{0, 1\}$ кожній вершині графа $G = (V, E)$, щоб позначити її бік розрізу. Ребро розрізане, коли його кінці лежать по різні боки, тому розмір розрізу дорівнює:

$$\mathrm{Cut}(x) = \sum_{(u,v) \in E} \left(x_u + x_v - 2 x_u x_v\right).$$

Ця цільова функція вже є QUBO без обмежень, тому OptimizationProblemToQubo лише перетворює максимізацію на еквівалентну мінімізацію та залишає змінні без змін. Клас застосунку Maxcut у qiskit_addon_opt_mapper.applications будує ту саму модель за допомогою Maxcut(G).to_optimization_problem().

import networkx as nx

G = nx.random_regular_graph(3, 40, seed=42)

linear = {v: 0 for v in G.nodes}
quadratic = {}
for u, v in G.edges:
    linear[u] += 1
    linear[v] += 1
    quadratic[(u, v)] = -2

maxcut = OptimizationProblem("MaxCut")
maxcut.binary_var_list(G.number_of_nodes(), name="x")
maxcut.maximize(linear=linear, quadratic=quadratic)

2. Запусти розв'язувач

Перетвори модель на QUBO, потім на словник і надішли її. problem і variable_type є обов'язковими. backend_name необов'язковий. Якщо його пропущено або він дорівнює None, функція обирає найменш завантажений робочий QPU, доступний твоєму інстансу.

Словник options приймає shots, seed, session, postprocessing_level і job_tags. Описи та значення за замовчуванням дивись у довіднику API.

qubo = OptimizationProblemToQubo().convert(maxcut)

job = solver.run(
    problem=to_problem_dict(qubo),
    variable_type="binary",
    backend_name="ibm_fez",
    options={
        "shots": 4096,
        "seed": 42,
    },
)

3. Отримай результат

job.result() повертає словник із чотирма ключами:

• solution — це повне призначення змінних із ключами x_i, де i — індекс змінної (наприклад, x_3).

• objective_value і feasible — це значення цільової функції та допустимість цього призначення, обчислені на поданому словнику.

• metadata містить solver_info і resource_usage.

Оскільки QUBO є формою мінімізації для MaxCut, objective_value є від'ємним значенням розміру розрізу. Обчисли призначення на вихідній OptimizationProblem, щоб прочитати розмір розрізу безпосередньо.

result = job.result()

x = [result["solution"][f"x_{i}"] for i in range(maxcut.get_num_vars())]
print(f"Cut value: {maxcut.objective.evaluate(x)}")
print(f"Nodes on side 1: {[v for v, value in enumerate(x) if value > 0.5]}")

Cut value: 55.0
Nodes on side 1: [5, 7, 9, 11, 14, 16, 17, 19, 21, 23, 24, 26, 30, 31, 33, 34, 36, 37, 38]

4. Перевір використання ресурсів

result["metadata"]["resource_usage"] показує час, витрачений на кожну фазу виконання. Фази, крім RUNNING: EXECUTING_QPU, повідомляють CPU_TIME — астрономічний час фази в секундах, якщо він доступний.

Фаза RUNNING: EXECUTING_QPU повідомляє QPU_TIME — використання QPU всіма завданнями Quantum Compute цього запуску, якщо остаточне використання доступне для кожного завдання. Подробиці дивись у довіднику API.

for phase, metrics in result["metadata"]["resource_usage"].items():
    line = f"{phase:36s}"
    if "CPU_TIME" in metrics:
        line += f" CPU {metrics['CPU_TIME']:8.1f} s"
    if "QPU_TIME" in metrics:
        line += f" QPU {metrics['QPU_TIME']:8.1f} s"
    print(line)

RUNNING: MAPPING                     CPU      3.2 s
RUNNING: OPTIMIZING_FOR_HARDWARE     CPU      5.0 s
RUNNING: WAITING_FOR_QPU             CPU      1.1 s
RUNNING: EXECUTING_QPU               QPU      3.0 s
RUNNING: POST_PROCESSING             CPU      0.9 s

Приклад 2: перетворення задачі з обмеженнями на QUBO

SQOA Solver приймає задачі без обмежень. Цей приклад показує, як перетворити задачу з обмеженнями на QUBO за допомогою OptimizationProblemToQubo і відобразити результат назад на змінні вихідної задачі.

selection = OptimizationProblem("ConstrainedExample")
selection.binary_var_list(2, name="x")
selection.maximize(linear={"x0": 1, "x1": 1})
selection.linear_constraint({"x0": 1, "x1": 1}, "<=", 1, name="at_most_one")

print(selection.prettyprint())

Problem name: ConstrainedExample

Maximize
  x0 + x1

Subject to
  Linear constraints (1)
    x0 + x1 <= 1  'at_most_one'

  Binary variables (2)
    x0 x1

OptimizationProblemToQubo додає обмеження до цільової функції як штрафні доданки та перетворює задачу на мінімізацію. Відповідна вага штрафу залежить від задачі.

Після запуску interpret() відображає призначення QUBO назад на змінні вихідної задачі.

Обчисли цільову функцію та допустимість на вихідній задачі. Для задачі у вигляді словника поле feasible результату стосується лише області значень змінних, оскільки словник не має обмежень.

converter = OptimizationProblemToQubo(penalty=4.0)
qubo = converter.convert(selection)

job = solver.run(
    problem=to_problem_dict(qubo),
    variable_type="binary",
    backend_name="ibm_fez",
)
result = job.result()

x_qubo = [result["solution"][f"x_{i}"] for i in range(qubo.get_num_vars())]
x = converter.interpret(x_qubo)
print("Objective:", selection.objective.evaluate(x))
print("Feasible:", selection.is_feasible(x))
print("x values:", x)

Objective: 1.0
Feasible: True
x values: [1. 0.]

Приклад 3: надсилання екземпляра OMMX

SQOA Solver також приймає ommx.v1.Instance з SDK OMMX, який зберігає назви змінних, індекси та метадані перетворення разом із задачею. Порівняно зі словником, вхідні дані OMMX мають такі переваги:

• Результат також містить канонічний ommx.v1.Solution у solver_info["ommx_solution"].

• objective_value обчислюється в сенсі екземпляра, тому цільова функція задачі максимізації не інвертується.

• Для екземпляра, перетвореного на місці за допомогою Instance.to_qubo(), feasible обчислюється відносно вихідних обмежень.

Цей приклад будує модель MaxCut з Прикладу 1 за допомогою JijModeling — засобу математичного моделювання оптимізації, який компілює моделі в екземпляри OMMX. Встанови JijModeling, який також встановлює пакет ommx:

# %pip install "jijmodeling~=2.8.0"

SQOA Solver обмінюється даними OMMX як стандартними рядками Base64 із доповненням. Визнач наведені нижче допоміжні функції для цього перетворення:

• to_problem_payload() серіалізує ommx.v1.Instance у рядок, який ти передаєш як problem.

• to_ommx_solution() декодує канонічний ommx.v1.Solution з результату.

import base64

from ommx.v1 import Instance, Solution

def to_problem_payload(instance: Instance) -> str:
    """Serialize an OMMX instance into the `problem` string for SQOA Solver."""
    return base64.b64encode(instance.to_bytes()).decode()

def to_ommx_solution(result: dict) -> Solution:
    """Decode the canonical OMMX solution from a SQOA Solver result."""
    payload = result["metadata"]["solver_info"]["ommx_solution"]
    return Solution.from_bytes(base64.b64decode(payload, validate=True))

1. Напиши модель за допомогою JijModeling

Звичайне спінове формулювання MaxCut на графі $G = (V, E)$ призначає $s_v \in \{-1, +1\}$ кожній вершині. Ребро розрізане, коли $s_u s_v = -1$, тому розмір розрізу дорівнює:

$$\operatorname{Cut}(s) = \sum_{(u,v) \in E} \frac{1 - s_u s_v}{2}.$$

JijModeling не надає власної спінової змінної рішення, а SQOA Solver приймає бінарні змінні QUBO. Тому оголоси $b_v \in \{0, 1\}$ і визнач спінове вираз $s_v = 1 - 2b_v$ усередині моделі. З цим виразом цільова функція залишається в стандартній спіновій формі, а скомпільований екземпляр залишається бінарним QUBO.

import jijmodeling as jm

@jm.Problem.define("MaxCut", sense=jm.ProblemSense.MAXIMIZE)
def maxcut_model(problem: jm.DecoratedProblem):
    V = problem.Natural()  # number of nodes
    E = problem.Graph(dtype=V)  # edge list
    b = problem.BinaryVar(shape=(V,))
    s = 1 - 2 * b  # spin-valued expression

    problem += jm.sum((1 - s[u] * s[v]) / 2 for u, v in E)

Якщо ти виведеш maxcut_model у ноутбуці, він покаже таке формулювання:

$$\begin{array}{rl} \text{Problem}\colon &\text{MaxCut}\\ \displaystyle \max &\displaystyle \sum _{\left\langle u,v\right\rangle \in E}{\frac{1-{\left(1-2\cdot b\right)}_{u}\cdot {\left(1-2\cdot b\right)}_{v}}{2}}\\ &\\ \text{where}&\\ &\text{Decision Variables:}\\ &\qquad \begin{alignedat}{2}{b}_{i}&\in \left\{0,1\right\}&\qquad &\text{a }1\text{-dim array of }\text{binary}\text{ decision variables}\\ &\forall i\in \left\{0,\ldots ,V-1\right\}&&\\ \end{alignedat}\\ &\\ &\text{Placeholders:}\\ &\qquad \begin{alignedat}{2}{E}_{i}&\in V\times V&\qquad &\text{a }1\text{-dim array of placeholders with elements in }V\times V\\ &\forall i\in \left\{0,\ldots ,\mathop{\mathtt{len\_{}at}}\left(E,0\right)-1\right\}&&\\ &&&\\ V&\in \mathbb{N}&\qquad &\text{a scalar placeholder in }\mathbb{N}\\ \end{alignedat}\end{array}$$

2. Скомпілюй екземпляр і запусти розв'язувач

Прив'яжи граф з Прикладу 1, щоб скомпілювати ommx.v1.Instance, і надішли його з variable_type="binary". Екземпляр OMMX завжди надсилається як бінарна задача.

instance = maxcut_model.eval(
    {"V": G.number_of_nodes(), "E": [list(edge) for edge in G.edges]}
)

job = solver.run(
    problem=to_problem_payload(instance),
    variable_type="binary",
    backend_name="ibm_fez",
)

3. Отримай результат

Для вхідних даних OMMX objective_value — це розмір розрізу, а to_ommx_solution() декодує канонічний розв'язок, щоб ти міг прочитати призначення за іменем змінної.

result = job.result()
print(f"Cut value: {result['objective_value']}")

solution = to_ommx_solution(result)
b_values = solution.extract_decision_variables("b")
print(
    f"Nodes on side 1: {sorted(v for (v,), value in b_values.items() if value > 0.5)}"
)

Cut value: 55.0
Nodes on side 1: [5, 7, 9, 11, 14, 16, 17, 19, 21, 23, 24, 26, 30, 31, 33, 34, 36, 37, 38]

Отримати підтримку

Для підтримки напиши на info@j-ij.com.

Наступні кроки

Рекомендації

• Запроси безкоштовну пробну версію SQOA Solver, заповнивши цю форму.
• Відвідай довідник API для цієї Qiskit Function.
• Спробуй наскрізний приклад у навчальному матеріалі про задачу максимальної незалежної множини.
• Дізнайся, як моделювати задачі оптимізації за допомогою qiskit-addon-opt-mapper.
• Дізнайся, як моделювати задачі оптимізації та обмінюватися ними за допомогою JijModeling і OMMX.
• Прочитай статтю про SQOA-QR [1], щоб дізнатися більше про фреймворк SQOA.

Посилання

[1] Matsuyama, H., & Yamashiro, Y. (2025). Sampling-based quantum optimization algorithm with quantum relaxation. 2025 IEEE International Conference on Quantum Computing and Engineering (QCE), 1, 2323–2333. DOI, arXiv:2504.12629

[2] Fuller, B., Hadfield, C., Glick, J. R., Imamichi, T., Itoko, T., Thompson, R. J., Jiao, Y., Kagele, M. M., Blom-Schieber, A. W., Raymond, R., et al. (2024). Approximate solutions of combinatorial problems via quantum relaxations. IEEE Transactions on Quantum Engineering, 5, 1–15. DOI, arXiv:2111.03167

[3] Robledo-Moreno, J., Motta, M., Haas, H., Javadi-Abhari, A., Jurcevic, P., Kirby, W., et al. (2025). Chemistry beyond the scale of exact diagonalization on a quantum-centric supercomputer. Science Advances, 11(25), eadu9991. DOI, arXiv:2405.05068

[4] Kanno, K., Kohda, M., Imai, R., Koh, S., Mitarai, K., Mizukami, W., & Nakagawa, Y. O. (2026). Quantum-selected configuration interaction: Classical diagonalization of Hamiltonians in subspaces selected by quantum computers. Physical Review Research, 8(2), 023268. DOI, arXiv:2302.11320