Parity Twine Optimizer: O funcție Qiskit de la ParityQC

Consultă referința API

notă

Qiskit Functions sunt o caracteristică experimentală disponibilă doar utilizatorilor IBM Quantum® cu plan Premium, plan Flex și plan On-Prem (prin API-ul IBM Quantum Platform). Acestea au statut de versiune preliminară (preview) și pot fi modificate.

Prezentare generală

Parity Twine Optimizer permite utilizatorilor să rezolve probleme de optimizare cu computere cuantice utilizând metoda Parity Twine. Această abordare, construită pe Parity Architecture, utilizează compilatorul ParityQC pentru a minimiza numărul de porți și adâncimea circuitului necesare pentru a rula un algoritm cuantic, ținând cont de conectivitatea dispozitivului.

Această reducere a resurselor permite rezolvarea unor probleme de optimizare relevante pentru industrie, la dimensiuni care sunt nefezabile cu metodele standard de transpilare, bogate în porți SWAP. Parity Twine Optimizer automatizează etapele de transpilare și poate fi utilizat cu o intervenție minimă din partea utilizatorului.

Abordarea Parity Twine depășește toate celelalte metode de compilare în ceea ce privește reducerea numărului de porți și a adâncimii circuitelor pentru algoritmi cuantici precum algoritmul de optimizare aproximativă cuantică (QAOA) și transformata Fourier cuantică (QFT). Prin decuplarea informației cuantice de qubiții fizici, interacțiunile non-locale sunt implementate fără porți SWAP. În schimb, lanțurile Parity Twine (secvențe de porți CNOT) distribuie sistematic informația logică de paritate între qubiți.

Optimizatorul utilizează QAOA pentru a minimiza energia unei funcții de cost date. QAOA este un algoritm variațional hibrid cuantic-clasic conceput pentru a rezolva probleme de optimizare combinatorială, aproximând starea fundamentală a unui hamiltonian de cost ($H_C$). Un termen de amestecare ($H_B$) determină tranziții între stări pentru a explora spațiul soluțiilor. O secvență alternantă a acestor termeni, controlată de parametrii $\gamma$ și $\beta$, definește operatorul unitar $U(\gamma, \beta) = \Pi_{i=1}^p e^{-i \beta_i H_B} e^{-i \gamma_i H_C}$, care acționează asupra stării inițiale.

Codificarea operatorului unitar al problemei, exp($-i \beta H_C)$), necesită codificarea tuturor operatorilor logici de rotație cu $n$ corpuri (exp($-i \beta J_{i,j,...n}Z_iZ_j...Z_n$)). Acest lucru se poate realiza folosind generatori cu $n$ corpuri (Parity Twine Networks), care reduc adâncimea circuitului QAOA și numărul de porți cu doi qubiți.

Descriere

Intrarea Parity Twine Optimizer constă dintr-o problemă de optimizare, numele hardware-ului IBM Quantum ales și argumente opționale suplimentare pentru a personaliza setările de transpilare și execuție pe hardware. Funcția optimizatorului direcționează definiția problemei către Parity Twine Compiler. Figura 1 prezintă un rezumat al fluxului de lucru al funcției.

Problema de optimizare de intrare este preprocesată într-un hamiltonian (normalizat). Compilatorul ParityQC construiește apoi un circuit ansatz Parity Twine parametrizat, care este transpilat într-un ansatz logic adaptat setului nativ de porți al hardware-ului ales.

Parametrii circuitului QAOA sunt optimizați clasic utilizând abordarea „efficient depth one” și sunt atribuiți circuitului transpilat. Deoarece se utilizează o singură rundă de QAOA, parametrii optimi $\gamma$ și $\beta$ sunt obținuți printr-o căutare pe grilă (grid search) pe CPU, fără a fi nevoie de o optimizare iterativă costisitoare pe parcursul multor apeluri de circuit. Acest lucru minimizează în mare măsură timpul de execuție necesar pe QPU al optimizatorului. Timpul de execuție per circuit este determinat în mare parte de suprasarcina constantă necesară pentru a rula un job pe QPU. Cu parametrii circuitului stabiliți, job-ul este trimis către QPU-ul IBM® specificat.

Rezultatele brute sunt apoi post-procesate. Această etapă utilizează o căutare locală de tip greedy care iterează aleatoriu prin șirul soluției și inversează valorile biților dacă acest lucru reduce valoarea funcției de cost.

Benchmark-uri

Precizare

Performanța poate depinde atât de instanța problemei, cât și de etapele de procesare ulterioare. În unele cazuri, eșantioanele clasice și cele generate cuantic pot atinge o calitate finală similară a soluției după o post-procesare echivalentă. Evaluarea ar trebui, prin urmare, să ia în considerare întregul flux de optimizare.

Modelul Sherrington-Kirkpatrick

Figura 2 demonstrează eficacitatea Parity Twine Optimizer. Aceasta compară rezultatele obținute utilizând optimizatorul cu eșantionarea aleatorie pentru modelul Sherrington-Kirkpatrick cu un număr crescând de qubiți.

Post-procesarea atât a rezultatelor aleatorii, cât și a celor ale optimizatorului conduce la stări fundamentale exacte, dar rezultatul brut al energiei minime de la Twine QAOA este întotdeauna mai bun decât valorile aleatorii. Pentru cele mai mari numere de qubiți considerate (90 și 100), zgomotul hardware degradează rezultatul optimizatorului, care revine la valori brute similare cu eșantionarea aleatorie.

Consultă acest tutorial pentru o introducere în modelul Sherrington-Kirkpatrick și detalii despre cum să îl rezolvi cu Parity Twine Optimizer.

Problema Market Split

Tabelul 1 prezintă metrici specifice de performanță pentru Parity Twine Optimizer, aplicat unor instanțe diverse ale problemei Market Split (MS). Acestea au fost obținute din QOBLIB - Quantum Optimization Benchmarking Library și corespund unor trimiteri făcute către bibliotecă utilizând Parity Twine Optimizer.

Încălcarea MS (MS violation) este o metrică de acuratețe care măsoară cât de departe este soluția de a satisface toate constrângerile, definită ca $\sum_i ((Ax - b)_i)^2$. Valori mai mici ale acestei metrici indică soluții mai precise. Tabelul 1 raportează valori medii pentru cinci rulări ale fiecărei instanțe, utilizând Parity Twine Optimizer cu dispozitivul ibm_boston ca backend și 100.000 de shot-uri. Se raportează încălcarea minimă MS obținută din rulările fiecărei instanțe.

Instanță	Qubiți	Porți cu doi qubiți	Adâncime cu doi qubiți	Încălcare MS	Timp de mapare (s)	Timp de execuție QPU (s)	Timp de post-procesare (s)
ms_03_050_002	20	399	76	0	45	29	71
ms_03_100_022	20	399	76	0	30	29	77
ms_03_200_177	20	399	76	0	33	29	63
ms_04_050_001	30	899	116	1	68	29	216
ms_04_100_003	30	899	116	2	89	29	187
ms_04_200_030	30	899	116	3	89	29	219
ms_05_100_003	40	1599	156	3	237	30	364
ms_06_050_001	50	2499	196	4	499	30	464
ms_07_050_001	60	3599	236	17	858	31	637
ms_08_050_001	70	4899	276	36	1561	31	773

Tabelul 1: Metrici de performanță pentru diferite instanțe ale problemei Market Split. Numele instanțelor corespund exemplelor din biblioteca de probleme QOBLIB. Așa cum s-a menționat anterior în secțiunea de descriere, timpul QPU este minim și aproape constant, deoarece se utilizează o singură rundă de QAOA cu parametrii optimi ai circuitului obținuți pe CPU.

Consultă acest tutorial pentru o introducere în problema Market Split și detalii despre cum să o rezolvi cu Parity Twine Optimizer.

Problema Maximum Independent Set

Figura 3 compară rezultatele obținute utilizând optimizatorul Parity Twine cu eșantionarea aleatorie pentru problema maximum independent set, pentru instanțe selectate obținute din QOBLIB - Quantum Optimization Benchmarking Library. Acestea variază de la 18 (mammalia-kangaroo-interactions) la 114 (es60fst03) qubiți.

Pentru instanțe mici, rezultatele brute ale dimensiunii Maximum Independent Set obținute de optimizator și de eșantionarea aleatorie sunt similare, dar pentru instanțe mai mari, optimizatorul oferă rezultate mult mai bune. Post-procesarea atât a rezultatelor eșantionate aleatoriu, cât și a celor ale optimizatorului conduce din nou la dimensiuni ale mulțimii în concordanță cu valorile exacte.

Primii pași

Autentifică-te folosind token-ul API IBM Quantum Platform și selectează funcția Qiskit astfel:

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

_needed = {"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

# Authenticate and load the Qiskit Function
catalog = QiskitFunctionsCatalog(
    channel="ibm_quantum_platform",
)
function = catalog.load("parityqc/parity-twine-optimizer")

Exemplu

Parity Twine Optimizer poate fi aplicat unui exemplu QUBO simplu, după cum urmează. Problema este definită mai întâi utilizând un dicționar:

problem = {"()": 3, "(0,)": 1, "(0, 1)": 2, "(1, 2)": -1}

Apoi, tipul variabilei trebuie definit ca binary sau spin:

variable_type = "spin"

Aceasta definește funcția obiectiv $3 + s_0 + 2 s_0s_1 - s_1s_2$, unde $s_i \in \{-1, 1\}$.

Alege un backend. De exemplu:

backend_name = "ibm_phoenix"

Utilizează catalog.backends() pentru a vedea o listă a backend-urilor disponibile din contul/instanța utilizatorului.

Dacă nu este specificat niciun backend, backend-ul cel mai puțin ocupat (cel cu cele mai puține job-uri în așteptare) este selectat automat.

Odată ce optimizatorul este încărcat (vezi mai sus), îl poți rula pe problemă utilizând opțiunile implicite:

function_job = function.run(
    problem=problem, variable_type=variable_type, backend_name=backend_name
)
print(f"Job ID: {function_job.job_id}")

Verifică starea job-ului astfel:

# Monitor the job status
function_job.status()

Preia rezultatele astfel:

# Retrieve the job result if the status is DONE
result = function_job.result()

result

Afișarea rezultatelor produce următoarele:

{
    'solution': {'0': -1, '1': 1, '2': 1},
    'objective_value': -1.0,
    'solution_bitstring': '100',
    'metadata': {
        'circuit_metrics': {
            'depth': 20,
            'gate_count': 198,
            'two_qubit_gate_depth': 4,
            'two_qubit_gate_count': 4,
            'num_qubits': 3,
            'operations': {'delay': 158, 'rz': 17, 'sx': 14, 'cz': 4, 'measure': 3, 'x': 2}
        },
        'solver_info': {
            'variable_mapping': {'0': 0, '1': 1, '2': 2},
            'bitstring_distributions': {
                'before_postprocessing': {'100': 71760, ... },
                'after_postprocessing': {'100': 88440, '011': 11560}
            },
            'best_parameters': {
                'beta': [-0.46259546391008877],
                'gamma': [0.6181957189727373]
            }
        },
        'resource_usage': {
            'RUNNING: MAPPING': {'CPU_TIME': 42.878},
            'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 0.094},
            'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 790.623},
            'RUNNING: EXECUTING_QPU': {'QPU_TIME': 28.0},
            'RUNNING: POST_PROCESSING': {'CPU_TIME': 0.828}
        }
    }
}

Dicționarul solution corespunde qubiților definiți în problemă ($s_0, s_1$ și $s_2$) și oferă valorile lor optimizate de spin.

objective_value reprezintă costul sau energia problemei de optimizare. Acesta cuantifică calitatea solution.

metadata oferă informații despre transpilare (numărul/adâncimea porților cu doi qubiți, porțile utilizate, qubiții activi) și diverși timpi de execuție atât pentru calculul cuantic, cât și pentru cel clasic.

În plus, metadata oferă o perspectivă asupra funcționării interne a algoritmului. Poți vedea parametrii variaționali optimizați (beta și gamma) și poți analiza cum s-a îmbunătățit distribuția șirurilor de biți măsurate după aplicarea post-procesării clasice asupra rezultatelor cuantice brute.

Toate șirurile de biți din rezultatul de ieșire pot fi mapate la variabilele problemei utilizând variable_mapping. De exemplu, poți mapa 'solution_bitstring': '100' cu 'variable_mapping': {'0': 0, '1': 1, '2': 2} la soluția binară: {'0': 1, '1': 0, '2': 0}. Deoarece rezolvi problema în termeni de variabile de spin, trebuie să aplici transformarea din binar în spin (0 -> 1, 1 -> -1 ). Ajungi apoi la soluția finală 'solution': {'0': -1, '1': 1, '2': 1}.

Consultă referința API pentru detalii complete despre intrarea și ieșirea funcției Parity Twine Optimizer.

Jurnal de modificări

[1.0.2] - 2026-09-15

Notes

Această versiune marchează prima versiune stabilă de producție a funcției Qiskit Parity Twine Optimizer. Se preconizează ca versiunile viitoare să introducă următoarele:

• compilarea problemelor de ordin superior,
• algoritmi de optimizare suplimentari și
• îmbunătățiri în pre- și post-procesare.

Funcționalități

• Rezolvă probleme QUBO cu structură rară (sparse) sau densă cu eficientul Parity Twine Compiler.

Documentație

• Ghid de inițiere pentru utilizatori.
• Tutoriale cu exemple pentru problemele Market Split și Sherrington-Kirkpatrick.
• Documentație API.

Obține asistență

Contactează ParityQC pentru orice întrebări sau probleme.

Pași următori

Recomandări

• Solicită acces la funcție completând acest formular.
• Vizitează referința API pentru această funcție Qiskit.
• Încearcă tutorialul pentru aplicarea Parity Twine Optimizer la problema Market Split.
• Încearcă tutorialul pentru aplicarea Parity Twine Optimizer la modelul Sherrington-Kirkpatrick.
• Consultă preprintul ArXiv Connectivity-aware Synthesis of Quantum Algorithms, Drier et al. (2025).