SQOA Solver - isang Qiskit Function ng JIJ

Tingnan ang API reference.

tala

Ang Qiskit Functions ay isang experimental na feature na available lang sa mga user ng IBM Quantum® Premium Plan, Flex Plan, at On-Prem (sa pamamagitan ng IBM Quantum Platform API) Plan. Nasa preview release status ito at puwedeng magbago.

Overview

Gamit ang SQOA Solver ng JIJ, malulutas mo ang malalaking combinatorial optimization problem sa mga quantum computer ng IBM®. Ang solver ay batay sa Sampling-based Quantum Optimization Algorithm with Quantum Relaxation (SQOA-QR) [1]. Hindi tulad ng mga quantum algorithm na gumagamit ng one-to-one mapping sa pagitan ng classical decision variable at qubit, kaya ng SQOA Solver na humawak ng mga optimization problem na mas marami ang variable kaysa sa bilang ng qubit na available sa mga kasalukuyang quantum device. Dahil sa sampling-based na disenyo nito, mas hindi rin ito sensitibo sa physical noise ng kasalukuyang quantum hardware. Dahil sa mga katangiang ito, bagay na bagay ang SQOA Solver sa mga optimization problem sa kasalukuyang yugto ng quantum computing.

Hinahawakan ng solver ang mga Quadratic Unconstrained Binary Optimization (QUBO) problem na ibinigay bilang classical mathematical formulation, at awtomatiko nitong imamapa ang classical formulation sa quantum setting. Puwede mo ring gawing unconstrained ang mga constrained problem gamit ang penalty method.

Inilalarawan ng mga sumusunod na seksyon ang workflow ng solver, mga resulta ng benchmark, at mga end-to-end na halimbawa na nagmo-model ng mga problema gamit ang qiskit-addon-opt-mapper at, opsyonal, ang Open Mathematical prograMming eXchange (OMMX). Ang OMMX ay isang open data format at SDK na nagpapadali sa pagpapalitan ng mga optimization problem sa pagitan ng mga software tool.

Paglalarawan

Ipinapatupad ng SQOA Solver ang Sampling-based Quantum Optimization Algorithm with Quantum Relaxation (SQOA-QR) at nilalagyan ito ng classical preprocessing at postprocessing sa paligid. Ipinapaliwanag ng seksyong ito ang SQOA framework at kung paano ito naiiba sa Quantum Approximate Optimization Algorithm (QAOA).

Ipinapakita ng sumusunod na figure ang schematic ng workflow ng SQOA Solver.

Ang SQOA framework

Ang SQOA ay isang sampling-based na framework para sa combinatorial optimization [1]. Pinagsasama nito ang dalawang technique: ang Quantum Random Access Optimization (QRAO) [2], na nag-e-encode ng problema sa isang quantum relaxation, at ang sample-based quantum diagonalization (SQD) [3], na kilala rin bilang quantum-selected configuration interaction (QSCI) [4], na gumagamit ng quantum computer para lang mag-sample ng mga bitstring at hinahanap ang low-energy state sa isang classical computer. Ang SQOA ay isang framework dahil itinatakda nito ang kombinasyong ito pero iniiwan ang mga detalye sa bawat implementasyon, tulad ng kung paano itinatalaga ang mga variable sa mga qubit at kung aling mga circuit ang gumagawa ng mga sample.

• Quantum relaxation gamit ang QRAO. Ang QAOA at iba pang Ising-based na approach ay kumakatawan sa bawat binary variable gamit ang $Z$ operator ng qubit nito. Gumagamit din ang QRAO ng mga $X$ at $Y$ operator. Sa (3,1) quantum random access code (QRAC), hanggang tatlong binary variable ang puwedeng magbahagi ng isang qubit, at ang bawat variable ay kinakatawan ng ibang Pauli operator.

  Ang QUBO ay nagiging relaxed Hamiltonian na mas kaunti ang kailangang qubit kaysa sa Ising Hamiltonian. Ang mga variable na nag-i-interact sa QUBO ay dapat ilagay sa magkakaibang qubit. Kung magbabahagi sila ng qubit, ang product ng kanilang mga Pauli operator ay magiging iisang operator na lang sa qubit na iyon (halimbawa, $XY = iZ$), at hindi na kakatawanin ng relaxed Hamiltonian ang interaction nila.

  Kaya ang pagtatalaga ng mga variable sa mga qubit ang nagtatakda ng bilang ng qubit at ng kalidad ng relaxation, at dinidisenyo ng SQOA Solver ang pagtatalagang ito sa preprocessing nito.

• Sample-based quantum diagonalization (SQD). Naghahanda muna ang quantum computer ng quantum state na may overlap sa mga low-energy state ng relaxed Hamiltonian, at pagkatapos ay nag-sample ng mga bitstring mula rito. Ipino-project ng classical computer ang relaxed Hamiltonian sa subspace na sakop ng mga na-sample na bitstring at dina-diagonalize ito para tantiyahin ang ground state.

  Dahil non-diagonal ang relaxed Hamiltonian, pinagsasama ng diagonalization ang mga na-sample na bitstring sa isang superposition. Sa diagonal na Ising Hamiltonian, eigenstate na ang bawat bitstring, at pipiliin lang ng diagonalization ang pinakamahusay na sample. Ang parehong approach ay naipatupad na sa malalaking problema sa quantum chemistry.

Ang tinatayang ground state na nakuha ng SQD ay hindi direktang tumutugma sa isang classical na solusyon ng orihinal na problema, kaya kailangang i-decode mula rito ang classical na solusyon. Dahil kinukuwenta ang state na ito sa isang classical computer, ang decoding, na tinatawag na rounding, ay classical postprocessing. Gumagamit ang SQOA Solver ng mga decoding technique na idinisenyo para heuristic na makakuha ng mas magagandang classical na solusyon.

Inihahambing ng sumusunod na table ang SQOA sa QAOA, isang karaniwang variational approach para sa parehong klase ng mga problema.

	QAOA	SQOA
Mga qubit para sa $n$ binary variable	$n$	Isang qubit ang may hawak ng hanggang tatlong variable. Nakadepende sa istruktura ng problema ang eksaktong bilang
Paggamit ng QPU	Paulit-ulit na tinatantiya ang energy ng mga parameterized circuit sa loob ng classical optimization loop	Nag-sample lang ng mga bitstring. Walang circuit parameter na tine-train sa QPU
Mula sa mga sample hanggang sa solusyon	Pinipili ang pinakamahusay na nasukat na bitstring	Dina-diagonalize ang relaxed Hamiltonian sa na-sample na subspace sa isang classical computer at nire-round ang nagresultang state

Sa paligid ng SQOA-QR, nagdaragdag ang SQOA Solver ng classical processing. Inaayos ng preprocessing nito ang mga variable na ang optimal na halaga ay matutukoy nang maaga at dinidisenyo ang pagtatalaga ng mga variable sa mga qubit. Pinipino ng postprocessing nito ang na-round na solusyon gamit ang local search, na puwede mong i-off gamit ang postprocessing_level=0.

Mga benchmark

Disclaimer

Ang performance ay puwedeng depende sa problem instance at sa mga sumunod na processing step. Sa ilang kaso, ang mga classical na sample at quantum-generated na sample ay puwedeng makakuha ng magkatulad na kalidad ng huling solusyon pagkatapos ng katumbas na postprocessing. Kaya dapat isaalang-alang sa pagsusuri ang buong optimization workflow.

Nagbibigay ang mga sumusunod na benchmark metric ng pangkalahatang indikasyon ng kalidad ng solusyon, qubit compression, at execution time sa mga piling laki at istruktura ng problema. Inililista ng table ang ilang piling Maximum Independent Set instance mula sa Quantum Optimization Benchmarking Library (QOBLIB) at dalawang 3-regular MaxCut instance. Puwede mong i-load ang mga QOBLIB instance bilang mga ommx.v1.Instance object, kasama ang kanilang mga optimal na solusyon, gamit ang package na ommx-quantum-benchmarks.

Bawat instance ay pinatakbo nang 10 beses sa isang IBM Heron r2 processor. Binibilang ng Number of qubits ang mga qubit na aktuwal na ginamit sa hardware pagkatapos ng preprocessing at QRAC encoding. Nakadepende sa instance ang compression ratio. Iniuulat ng Approximation ratio (AR) ang kalidad ng pinakamahusay na solusyong nahanap sa loob ng 10 run:

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

kung saan ang $C_{\textrm{best}}$ ay ang pinakamahusay na objective value na nahanap at ang $C_{\textrm{opt}}$ ay ang kilalang optimal na objective value. Lahat ng instance ay maximization problem na may positibong optimal value, kaya ang AR ay hindi lalampas sa 100%, at ang 100% sa column na Approximation ratio ay nangangahulugang nakahanap ang solver ng optimal na solusyon. Ang Total time ay ang average na pinagsamang QPU at CPU time bawat run. Ang QPU time ay ang average na paggamit ng IBM Quantum Compute bawat run.

Instance	Bilang ng mga variable	Bilang ng mga qubit	Approximation ratio	Kabuuang oras (segundo)	QPU time (segundo)
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

Magsimula

Hanapin ang access information para sa Qiskit Function na ito sa Qiskit Functions Catalog.

Ipinapakita ng seksyong ito kung paano mag-authenticate at mag-load ng function, at kung paano maghanda ng problema sa dictionary format na tinatanggap ng SQOA Solver gamit ang OptimizationProblem mula sa qiskit-addon-opt-mapper. Pinapatakbo ng mga susunod na halimbawa ang function at binabasa ang resulta.

Mag-authenticate at i-load ang function

Una, mag-authenticate gamit ang iyong IBM Quantum API key. (Ipinapalagay ng sumusunod na code na na-save mo na ang account mo sa local environment mo.) Pagkatapos, gumawa ng catalog client gaya ng sumusunod:

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

Ihanda ang input gamit ang qiskit-addon-opt-mapper

Nagmo-model ang gabay na ito ng mga problema gamit ang OptimizationProblem class ng qiskit-addon-opt-mapper. Tumatanggap ang SQOA Solver ng QUBO problem bilang coefficient dictionary sa tuple-string format na ginagamit ng mga IBM optimization function, kaya ang bawat halimbawa sa gabay na ito ay sumusunod sa parehong client-side na pattern ng paghahanda:

1. Isulat ang model. Gumawa ng OptimizationProblem, magdagdag ng mga binary decision variable, at itakda ang objective at anumang constraint.

2. I-convert sa QUBO. I-convert ang problema gamit ang OptimizationProblemToQubo, na nagdaragdag ng anumang constraint sa objective bilang mga penalty term at nagbabalik ng katumbas na unconstrained minimization problem.

3. I-convert sa dictionary. Ipasa ang QUBO sa helper function na to_problem_dict() na tinukoy sa susunod na seksyon, at ipasa ang resulta sa solver.run() bilang problem, kasama ang variable_type="binary".

Laging minimina ng SQOA Solver ang isang dictionary problem, na tugma sa minimization problem na ibinabalik ng OptimizationProblemToQubo. Para sa maximization problem, ang ibinalik na objective_value ay ang negatibo ng orihinal na objective. Para mabasa ang resulta ayon sa orihinal na problema, i-evaluate ang ibinalik na assignment gamit ang OptimizationProblem, gaya ng ipinapakita ng mga halimbawa. Para sa mga detalye ng dictionary format, tingnan ang Accepted problem formats sa API reference.

# %pip install qiskit-addon-opt-mapper

Tukuyin nang isang beses ang sumusunod na helper function at gamitin ito ulit sa bawat halimbawa. Kino-convert nito ang QUBO na ibinalik ng OptimizationProblemToQubo sa dictionary format. Ang mga key ay gumagamit ng mga variable index ng QUBO, kaya ang mga solution key na x_0, x_1, at iba pa sa resulta ay tumutugma sa mga index na iyon. Bawat variable ay tumatanggap ng linear entry, kahit zero ang coefficient, para saklaw ng ibinalik na solusyon ang lahat ng variable.

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

Halimbawa 1: MaxCut sa isang 3-regular na graph

Maraming graph problem, tulad ng MaxCut, ay NP-hard at natural na kandidato para sa quantum optimization. I-install ang networkx bilang karagdagang dependency para patakbuhin ang halimbawang ito:

# %pip install networkx

1. Isulat ang model

Magtalaga ng binary variable na $x_v \in \{0, 1\}$ sa bawat vertex ng graph na $G = (V, E)$ para ipahiwatig ang panig nito sa cut. Ang isang edge ay na-cut kapag magkaibang panig ang mga dulo nito, kaya ang laki ng cut ay:

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

Ang objective na ito ay QUBO na mismo nang walang constraint, kaya ginagawa lang ng OptimizationProblemToQubo na katumbas na minimization ang maximization at pinananatiling hindi nagbabago ang mga variable. Binubuo ng Maxcut application class sa qiskit_addon_opt_mapper.applications ang parehong model gamit ang 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. Patakbuhin ang solver

I-convert ang model sa QUBO at pagkatapos ay sa dictionary, at isumite ito. Kailangan ang problem at variable_type. Opsyonal ang backend_name. Kapag hindi ito ibinigay o None, pinipili ng function ang pinakamaluwag na operational na QPU na available sa instance mo.

Tumatanggap ang options dictionary ng shots, seed, session, postprocessing_level, at job_tags. Para sa mga paglalarawan at default, tingnan ang API reference.

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. Kunin ang resulta

Nagbabalik ang job.result() ng dictionary na may apat na key:

• Ang solution ay ang kumpletong variable assignment, na naka-key sa x_i, kung saan ang i ay ang variable index (halimbawa, x_3).

• Ang objective_value at feasible ay ang objective at feasibility ng assignment na iyon, na na-evaluate sa isinumiteng dictionary.

• Hawak ng metadata ang solver_info at resource_usage.

Dahil ang QUBO ang minimization form ng MaxCut, ang objective_value ay ang negatibo ng laki ng cut. I-evaluate ang assignment sa orihinal na OptimizationProblem para direktang mabasa ang laki ng cut.

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. Suriin ang resource usage

Iniuulat ng result["metadata"]["resource_usage"] ang oras na ginugol sa bawat execution phase. Ang mga phase maliban sa RUNNING: EXECUTING_QPU ay nag-uulat ng CPU_TIME, ang wall-clock time ng phase sa segundo, kapag available ito.

Iniuulat ng phase na RUNNING: EXECUTING_QPU ang QPU_TIME, ang QPU usage ng lahat ng Quantum Compute job ng run, kung available ang huling usage para sa bawat job. Para sa mga detalye, tingnan ang API reference.

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

Halimbawa 2: I-convert ang constrained problem sa QUBO

Tumatanggap ang SQOA Solver ng mga unconstrained problem. Ipinapakita ng halimbawang ito kung paano i-convert ang constrained problem sa QUBO gamit ang OptimizationProblemToQubo at imapa pabalik ang resulta sa mga variable ng orihinal na problema.

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

Idinaragdag ng OptimizationProblemToQubo ang mga constraint sa objective bilang mga penalty term at kino-convert ang problema sa minimization. Nakadepende sa problema ang angkop na penalty weight.

Pagkatapos ng run, imamapa pabalik ng interpret() ang QUBO assignment sa mga variable ng orihinal na problema.

I-evaluate ang objective at ang feasibility sa orihinal na problema. Para sa dictionary problem, ang field na feasible ng resulta ay tumutukoy lang sa variable domain, dahil walang constraint ang dictionary.

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

Halimbawa 3: Magsumite ng OMMX instance

Tumatanggap din ang SQOA Solver ng ommx.v1.Instance mula sa OMMX SDK, na pinagsasama ang mga variable name, subscript, at conversion metadata kasama ng problema. Kumpara sa dictionary, may mga sumusunod na bentahe ang OMMX input:

• Naglalaman din ang resulta ng canonical na ommx.v1.Solution sa solver_info["ommx_solution"].

• Ang objective_value ay ine-evaluate ayon sa instance, kaya hindi ginagawang negatibo ang objective ng maximization problem.

• Para sa instance na kinonvert in place gamit ang Instance.to_qubo(), ang feasible ay ine-evaluate laban sa mga orihinal na constraint.

Binubuo ng halimbawang ito ang MaxCut model mula sa Halimbawa 1 gamit ang JijModeling, isang mathematical optimization modeler na nagko-compile ng mga model sa mga OMMX instance. I-install ang JijModeling, na nag-i-install din ng package na ommx:

# %pip install "jijmodeling~=2.8.0"

Nagpapalitan ang SQOA Solver ng OMMX data bilang standard padded Base64 string. Tukuyin ang sumusunod na helper function para sa conversion na ito:

• Sine-serialize ng to_problem_payload() ang isang ommx.v1.Instance sa string na ipinapasa mo bilang problem.

• Dine-decode ng to_ommx_solution() ang canonical na ommx.v1.Solution mula sa resulta.

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. Isulat ang model gamit ang JijModeling

Ang karaniwang spin formulation ng MaxCut sa graph na $G = (V, E)$ ay nagtatalaga ng $s_v \in \{-1, +1\}$ sa bawat vertex. Ang isang edge ay na-cut kapag $s_u s_v = -1$, kaya ang laki ng cut ay:

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

Walang native na spin decision variable ang JijModeling, at tumatanggap ang SQOA Solver ng mga binary QUBO variable. Kaya, magdeklara ng $b_v \in \{0, 1\}$ at tukuyin ang spin-valued na expression $s_v = 1 - 2b_v$ sa loob ng model. Sa expression na ito, nananatili ang objective sa standard spin form, at ang na-compile na instance ay nananatiling binary 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)

Kung ipapakita mo ang maxcut_model sa isang notebook, ipinapakita nito ang sumusunod na formulation:

$$\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. I-compile ang instance at patakbuhin ang solver

I-bind ang graph mula sa Halimbawa 1 para mag-compile ng ommx.v1.Instance, at isumite ito gamit ang variable_type="binary". Ang OMMX instance ay laging isinusumite bilang binary problem.

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. Kunin ang resulta

Para sa OMMX input, ang objective_value ay ang laki ng cut, at dine-decode ng to_ommx_solution() ang canonical na solusyon para mabasa mo ang assignment ayon sa variable name.

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]

Kumuha ng suporta

Para sa suporta, mag-email sa info@j-ij.com.

Mga susunod na hakbang

Mga rekomendasyon

• Humiling ng libreng trial ng SQOA Solver sa pamamagitan ng pagkumpleto ng form na ito.
• Bisitahin ang API reference para sa Qiskit Function na ito.
• Subukan ang isang end-to-end na halimbawa sa tutorial na maximum independent set problem.
• Alamin kung paano mag-model ng mga optimization problem gamit ang qiskit-addon-opt-mapper.
• Alamin kung paano mag-model at magpalitan ng mga optimization problem gamit ang JijModeling at OMMX.
• Basahin ang SQOA-QR paper [1] para matuto pa tungkol sa SQOA framework.

Mga sanggunian

[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