SQOA Solver - Qiskit Function od JIJ

Viz referenční dokumentace API.

poznámka

Qiskit Functions jsou experimentální funkce dostupná pouze uživatelům plánů IBM Quantum® Premium Plan, Flex Plan a On-Prem (přes IBM Quantum Platform API) Plan. Jsou ve stavu náhledového vydání a mohou se změnit.

Přehled

S SQOA Solver od JIJ můžeš řešit rozsáhlé kombinatorické optimalizační problémy na kvantových počítačích IBM®. Solver vychází z algoritmu Sampling-based Quantum Optimization Algorithm with Quantum Relaxation (SQOA-QR) [1]. Na rozdíl od kvantových algoritmů, které používají vzájemně jednoznačné mapování mezi klasickými rozhodovacími proměnnými a qubity, si SQOA Solver poradí s optimalizačními problémy s více proměnnými, než kolik qubitů mají dnešní kvantová zařízení. Jeho návrh založený na vzorkování je také méně citlivý na fyzikální šum současného kvantového hardwaru. Díky těmto vlastnostem se SQOA Solver dobře hodí pro optimalizační problémy v současné fázi vývoje kvantových počítačů.

Solver řeší problémy kvadratické neomezené binární optimalizace (QUBO) zadané jako klasická matematická formulace a klasickou formulaci automaticky převádí do kvantového prostředí. Problémy s omezeními můžeš také převést na problémy bez omezení pomocí penalizační metody.

Následující části popisují workflow solveru, výsledky benchmarků a kompletní příklady, které modelují problémy pomocí qiskit-addon-opt-mapper a volitelně pomocí Open Mathematical prograMming eXchange (OMMX). OMMX je otevřený datový formát a SDK, které zjednodušují výměnu optimalizačních problémů mezi softwarovými nástroji.

Popis

SQOA Solver implementuje algoritmus Sampling-based Quantum Optimization Algorithm with Quantum Relaxation (SQOA-QR) a obklopuje ho klasickým předzpracováním a následným zpracováním. Tato část vysvětluje framework SQOA a v čem se liší od Quantum Approximate Optimization Algorithm (QAOA).

Následující obrázek ukazuje schéma workflow SQOA Solver.

Framework SQOA

SQOA je framework pro kombinatorickou optimalizaci založený na vzorkování [1]. Kombinuje dvě techniky: Quantum Random Access Optimization (QRAO) [2], která kóduje problém do kvantové relaxace, a sample-based quantum diagonalization (SQD) [3], známou také jako quantum-selected configuration interaction (QSCI) [4], která používá kvantový počítač pouze ke vzorkování bitových řetězců a stav s nízkou energií hledá na klasickém počítači. SQOA je framework v tom smyslu, že tuto kombinaci pevně stanovuje, ale detaily nechává na jednotlivých implementacích, například způsob přiřazení proměnných qubitům a to, jaké obvody generují vzorky.

• Kvantová relaxace pomocí QRAO. QAOA a další přístupy založené na Isingově modelu reprezentují každou binární proměnnou operátorem $Z$ jejího qubitu. QRAO používá také operátory $X$ a $Y$. S kvantovým kódem náhodného přístupu (QRAC) typu (3,1) sdílejí až tři binární proměnné jeden qubit a každá proměnná je reprezentována jiným Pauliho operátorem.

  QUBO se pak změní na relaxovaný hamiltonián, který potřebuje méně qubitů než Isingův hamiltonián. Proměnné, které v QUBO interagují, musí být umístěny na různých qubitech. Pokud by sdílely qubit, součin jejich Pauliho operátorů by se zredukoval na jediný operátor na tomto qubitu (například $XY = iZ$) a relaxovaný hamiltonián by už jejich interakci nereprezentoval.

  Přiřazení proměnných qubitům tedy určuje jak počet qubitů, tak kvalitu relaxace, a SQOA Solver toto přiřazení navrhuje ve svém předzpracování.

• Sample-based quantum diagonalization (SQD). Kvantový počítač nejprve připraví kvantový stav, který se překrývá se stavy relaxovaného hamiltoniánu s nízkou energií, a poté z něj vzorkuje bitové řetězce. Klasický počítač promítne relaxovaný hamiltonián do podprostoru generovaného vzorkovanými bitovými řetězci a diagonalizuje ho, aby aproximoval základní stav.

  Protože relaxovaný hamiltonián není diagonální, diagonalizace kombinuje vzorkované bitové řetězce do superpozice. U diagonálního Isingova hamiltoniánu je každý bitový řetězec už vlastním stavem a diagonalizace by pouze vybrala nejlepší vzorek. Stejný přístup byl použit na rozsáhlé problémy v kvantové chemii.

Přibližný základní stav získaný pomocí SQD přímo neodpovídá klasickému řešení původního problému, takže z něj je třeba klasické řešení dekódovat. Protože se tento stav počítá na klasickém počítači, je dekódování, nazývané zaokrouhlování, klasickým následným zpracováním. SQOA Solver používá techniky dekódování navržené tak, aby heuristicky získaly lepší klasická řešení.

Následující tabulka porovnává SQOA s QAOA, běžným variačním přístupem ke stejné třídě problémů.

	QAOA	SQOA
Qubity pro $n$ binárních proměnných	$n$	Jeden qubit pojme až tři proměnné. Přesný počet závisí na struktuře problému
Využití QPU	Opakovaně odhaduje energii parametrizovaných obvodů uvnitř klasické optimalizační smyčky	Pouze vzorkuje bitové řetězce. Na QPU se netrénují žádné parametry obvodu
Od vzorků k řešení	Vybere nejlepší naměřený bitový řetězec	Diagonalizuje relaxovaný hamiltonián ve vzorkovaném podprostoru na klasickém počítači a výsledný stav zaokrouhlí

Kolem SQOA-QR přidává SQOA Solver klasické zpracování. Jeho předzpracování fixuje proměnné, jejichž optimální hodnoty lze určit předem, a navrhuje přiřazení proměnných qubitům. Jeho následné zpracování zpřesňuje zaokrouhlené řešení lokálním prohledáváním, které můžeš vypnout pomocí postprocessing_level=0.

Benchmarky

Upozornění

Výkon může záviset jak na konkrétní instanci problému, tak na následných krocích zpracování. V některých případech mohou klasické vzorky a kvantově generované vzorky po ekvivalentním následném zpracování dosáhnout podobné kvality konečného řešení. Hodnocení proto musí zohlednit celý optimalizační workflow.

Následující metriky benchmarků poskytují obecnou představu o kvalitě řešení, kompresi qubitů a době provádění pro vybrané velikosti a struktury problémů. Tabulka uvádí výběr instancí problému maximální nezávislé množiny z knihovny Quantum Optimization Benchmarking Library (QOBLIB) a dvě 3-regulární instance problému MaxCut. Instance QOBLIB můžeš načíst jako objekty ommx.v1.Instance spolu s jejich optimálními řešeními pomocí balíčku ommx-quantum-benchmarks.

Každá instance byla spuštěna 10krát na procesoru IBM Heron r2. Number of qubits udává počet qubitů skutečně použitých na hardwaru po předzpracování a kódování QRAC. Kompresní poměr závisí na instanci. Approximation ratio (AR) udává kvalitu nejlepšího řešení nalezeného během 10 spuštění:

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

kde $C_{\textrm{best}}$ je nejlepší nalezená hodnota cíle a $C_{\textrm{opt}}$ je známá optimální hodnota cíle. Všechny instance jsou maximalizační problémy s kladnou optimální hodnotou, takže AR je nejvýše 100 % a 100 % ve sloupci Approximation ratio znamená, že solver našel optimální řešení. Total time je průměrný kombinovaný čas QPU a CPU na jedno spuštění. QPU time je průměrné využití IBM Quantum Compute na jedno spuštění.

Instance	Počet proměnných	Počet qubitů	Aproximační poměr	Celkový čas (sekundy)	Čas QPU (sekundy)
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

Začínáme

Informace o přístupu k této Qiskit Function najdeš v katalogu Qiskit Functions.

Tato část ukazuje, jak se autentizovat a načíst funkci a jak připravit problém ve formátu slovníku, který SQOA Solver přijímá, pomocí OptimizationProblem z qiskit-addon-opt-mapper. Následující příklady funkci spouštějí a čtou výsledek.

Autentizace a načtení funkce

Nejprve se autentizuj pomocí svého API klíče IBM Quantum. (Následující kód předpokládá, že jsi už uložil(a) svůj účet do místního prostředí.) Poté vytvoř klienta katalogu takto:

# 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")

Příprava vstupu pomocí qiskit-addon-opt-mapper

Tento návod modeluje problémy pomocí třídy OptimizationProblem z qiskit-addon-opt-mapper. SQOA Solver přijímá problém QUBO jako slovník koeficientů ve formátu řetězců n-tic používaném optimalizačními funkcemi IBM, takže každý příklad v tomto návodu následuje stejný vzor přípravy na straně klienta:

1. Napiš model. Vytvoř OptimizationProblem, přidej binární rozhodovací proměnné a nastav cíl a případná omezení.

2. Převeď na QUBO. Převeď problém pomocí OptimizationProblemToQubo, které přidá případná omezení do cíle jako penalizační členy a vrátí ekvivalentní minimalizační problém bez omezení.

3. Převeď na slovník. Předej QUBO pomocné funkci to_problem_dict() definované v další části a výsledek předej do solver.run() jako problem spolu s variable_type="binary".

SQOA Solver vždy minimalizuje slovníkový problém, což odpovídá minimalizačnímu problému, který vrací OptimizationProblemToQubo. U maximalizačního problému je proto vrácená hodnota objective_value záporná hodnota původního cíle. Chceš-li výsledek číst z hlediska původního problému, vyhodnoť vrácené přiřazení pomocí OptimizationProblem, jak ukazují příklady. Podrobnosti o formátu slovníku najdeš v části Accepted problem formats v referenční dokumentaci API.

# %pip install qiskit-addon-opt-mapper

Následující pomocnou funkci definuj jednou a použij ji v každém příkladu. Převádí QUBO vrácené z OptimizationProblemToQubo do formátu slovníku. Klíče používají indexy proměnných QUBO, takže klíče řešení x_0, x_1 atd. ve výsledku odpovídají těmto indexům. Každá proměnná dostane lineární položku, i s nulovým koeficientem, aby vrácené řešení pokrývalo všechny proměnné.

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()}

Příklad 1: MaxCut na 3-regulárním grafu

Mnoho grafových problémů, například MaxCut, je NP-těžkých a přirozeně se nabízejí pro kvantovou optimalizaci. Pro spuštění tohoto příkladu nainstaluj jako další závislost networkx:

# %pip install networkx

1. Napiš model

Přiřaď binární proměnnou $x_v \in \{0, 1\}$ každému vrcholu grafu $G = (V, E)$, která označuje jeho stranu řezu. Hrana je přeříznuta, když její koncové body leží na různých stranách, takže velikost řezu je:

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

Tento cíl je už QUBO bez omezení, takže OptimizationProblemToQubo pouze změní maximalizaci na ekvivalentní minimalizaci a proměnné ponechá beze změny. Aplikační třída Maxcut v qiskit_addon_opt_mapper.applications sestaví stejný model pomocí 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. Spusť solver

Převeď model na QUBO a poté na slovník a odešli ho. problem a variable_type jsou povinné. backend_name je volitelný. Pokud je vynechán nebo je None, funkce vybere nejméně vytížené provozní QPU dostupné pro tvoji instanci.

Slovník options přijímá shots, seed, session, postprocessing_level a job_tags. Popisy a výchozí hodnoty najdeš v referenční dokumentaci 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. Získej výsledek

job.result() vrací slovník se čtyřmi klíči:

• solution je úplné přiřazení proměnných s klíči x_i, kde i je index proměnné (například x_3).

• objective_value a feasible jsou hodnota cíle a přípustnost tohoto přiřazení, vyhodnocené na odeslaném slovníku.

• metadata obsahuje solver_info a resource_usage.

Protože QUBO je minimalizační podoba MaxCut, je objective_value záporná velikost řezu. Chceš-li velikost řezu přečíst přímo, vyhodnoť přiřazení na původním 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. Zkontroluj využití zdrojů

result["metadata"]["resource_usage"] uvádí čas strávený v každé fázi provádění. Fáze jiné než RUNNING: EXECUTING_QPU uvádějí CPU_TIME, tedy reálný čas fáze v sekundách, pokud je dostupný.

Fáze RUNNING: EXECUTING_QPU uvádí QPU_TIME, tedy využití QPU všemi úlohami Quantum Compute daného spuštění, pokud je konečné využití dostupné pro každou úlohu. Podrobnosti najdeš v referenční dokumentaci 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

Příklad 2: Převod problému s omezeními na QUBO

SQOA Solver přijímá problémy bez omezení. Tento příklad ukazuje, jak převést problém s omezeními na QUBO pomocí OptimizationProblemToQubo a výsledek namapovat zpět na proměnné původního problému.

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 přidá omezení do cíle jako penalizační členy a převede problém na minimalizaci. Vhodná váha penalizace závisí na problému.

Po spuštění interpret() namapuje přiřazení QUBO zpět na proměnné původního problému.

Vyhodnoť cíl a přípustnost na původním problému. U slovníkového problému se pole feasible ve výsledku vztahuje pouze k definičnímu oboru proměnných, protože slovník neobsahuje žádná omezení.

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.]

Příklad 3: Odeslání instance OMMX

SQOA Solver přijímá také ommx.v1.Instance ze SDK OMMX, která uchovává názvy proměnných, indexy a metadata převodu pohromadě s problémem. Ve srovnání se slovníkem má vstup OMMX následující výhody:

• Výsledek také obsahuje kanonické ommx.v1.Solution v solver_info["ommx_solution"].

• objective_value se vyhodnocuje ve smyslu instance, takže cíl maximalizačního problému není negován.

• U instance převedené na místě pomocí Instance.to_qubo() se feasible vyhodnocuje vůči původním omezením.

Tento příklad sestavuje model MaxCut z příkladu 1 pomocí JijModeling, nástroje pro matematické modelování optimalizace, který kompiluje modely do instancí OMMX. Nainstaluj JijModeling, který nainstaluje také balíček ommx:

# %pip install "jijmodeling~=2.8.0"

SQOA Solver vyměňuje data OMMX jako standardní řetězce Base64 s paddingem. Pro tento převod definuj následující pomocné funkce:

• to_problem_payload() serializuje ommx.v1.Instance do řetězce, který předáš jako problem.

• to_ommx_solution() dekóduje kanonické ommx.v1.Solution z výsledku.

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. Napiš model pomocí JijModeling

Obvyklá spinová formulace MaxCut na grafu $G = (V, E)$ přiřazuje každému vrcholu $s_v \in \{-1, +1\}$. Hrana je přeříznuta, když $s_u s_v = -1$, takže velikost řezu je:

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

JijModeling neposkytuje nativní spinovou rozhodovací proměnnou a SQOA Solver přijímá binární proměnné QUBO. Proto deklaruj $b_v \in \{0, 1\}$ a uvnitř modelu definuj výraz se spinovou hodnotou $s_v = 1 - 2b_v$. S tímto výrazem zůstává cíl ve standardní spinové podobě a zkompilovaná instance zůstává binárním 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)

Pokud v notebooku zobrazíš maxcut_model, zobrazí následující formulaci:

$$\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. Zkompiluj instanci a spusť solver

Naváž graf z příkladu 1, abys zkompiloval(a) ommx.v1.Instance, a odešli ji s variable_type="binary". Instance OMMX se vždy odesílá jako binární problém.

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. Získej výsledek

U vstupu OMMX je objective_value velikost řezu a to_ommx_solution() dekóduje kanonické řešení, abys mohl(a) číst přiřazení podle názvu proměnné.

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]

Získání podpory

Podporu získáš e-mailem na info@j-ij.com.

Další kroky

Doporučení

• Požádej o bezplatnou zkušební verzi SQOA Solver vyplněním tohoto formuláře.
• Navštiv referenční dokumentaci API k této Qiskit Function.
• Vyzkoušej kompletní příklad ve výukovém programu problém maximální nezávislé množiny.
• Zjisti, jak modelovat optimalizační problémy pomocí qiskit-addon-opt-mapper.
• Zjisti, jak modelovat a vyměňovat optimalizační problémy pomocí JijModeling a OMMX.
• Přečti si článek o SQOA-QR [1], abys se o frameworku SQOA dozvěděl(a) více.

Reference

[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