Parity Twine Optimizer: una funzione di Qiskit realizzata da ParityQC

Consulta la guida alle API

Panoramica

Il Parity Twine Optimizer consente agli utenti di risolvere problemi di ottimizzazione con i computer quantistici utilizzando il metodo Parity Twine. Questo approccio, basato sull’architettura Parity, utilizza il compilatore “ ParityQC ” per ridurre al minimo il numero di porte logiche e la profondità dei circuiti necessari per l’esecuzione di un algoritmo quantistico, tenendo conto al contempo della connettività dei dispositivi.

Questa riduzione delle risorse consente di risolvere problemi di ottimizzazione rilevanti per l'industria su scale che risultano irrealizzabili con i metodi di transpilazione standard, che comportano un elevato carico di SWAP. Il Parity Twine Optimizer automatizza le fasi di transpilazione e può essere utilizzato con un intervento minimo da parte dell'utente.

L'approccio Parity Twine supera tutti gli altri metodi di compilazione in termini di riduzione del numero di porte logiche e della profondità dei circuiti per algoritmi quantistici quali l' algoritmo di ottimizzazione approssimativa quantistica (QAOA) e la trasformata di Fourier quantistica (QFT). Astraendo l’informazione quantistica dai qubit fisici, è possibile realizzare interazioni non locali senza ricorrere ai gate SWAP. Al contrario, le catene Parity Twine (sequenze di porte CNOT) distribuiscono sistematicamente le informazioni di parità logica tra i qubit.

L'ottimizzatore utilizza l'algoritmo QAOA per minimizzare l'energia di una data funzione di costo. QAOA è un algoritmo variazionale ibrido quantistico-classico progettato per risolvere problemi di ottimizzazione combinatoria mediante l'approssimazione dello stato fondamentale di un hamiltoniano di costo ( $H_C$ ). Un termine di miscelazione ( $H_B$ ) guida le transizioni tra gli stati per esplorare lo spazio delle soluzioni. Una sequenza alternata di questi termini, controllata dai parametri $\gamma$ e $\beta$, definisce l' $U(\gamma, \beta) = \Pi_{i=1}^p e^{-i \beta_i H_B} e^{-i \gamma_i H_C}$ unitaria, che agisce sullo stato iniziale.

La codifica dell'operatore unitario del problema, exp( $-i \beta H_C)$ ), richiede la codifica di tutti gli operatori logici di rotazione a $n$ i (exp( $-i \beta J_{i,j,...n}Z_iZ_j...Z_n$ )). Ciò può essere ottenuto utilizzando generatori a $n$ i (Parity Twine Networks), che riducono la profondità del circuito QAOA e il numero di gate a due qubit.

Descrizione

L'input di Parity Twine Optimizer è costituito da un problema di ottimizzazione, dal nome dell'hardware IBM Quantum selezionato e da ulteriori argomenti opzionali per personalizzare le impostazioni di transpilazione ed esecuzione hardware. La funzione “ottimizzatore” inoltra la definizione del problema al compilatore Parity Twine. La figura 1 mostra una sintesi del flusso di lavoro della funzione.

Il problema di ottimizzazione degli input viene pre-elaborato in un hamiltoniano (normalizzato). Il compilatore ParityQC a quindi un circuito di ansatz Parity Twine parametrizzato, che viene transpilato in un ansatz logico corrispondente all'insieme di porte nativo dell'hardware scelto.

I parametri del circuito QAOA vengono tradizionalmente ottimizzati utilizzando l’approccio “efficient depth one” e assegnati al circuito transpilato. Poiché viene utilizzato un solo ciclo di QAOA, i parametri ottimali $\gamma$ e $\beta$ vengono ottenuti tramite una ricerca a griglia su una CPU, senza la necessità di una costosa ottimizzazione iterativa su numerose chiamate al circuito. Ciò riduce notevolmente il tempo di esecuzione della QPU richiesto dall'ottimizzatore. Il tempo di esecuzione per circuito è determinato principalmente dal sovraccarico costante necessario per eseguire un’operazione sulla QPU. Una volta impostati i parametri del circuito, il lavoro viene inviato alla QPU specificata IBM®.

I risultati grezzi vengono quindi sottoposti a post-elaborazione. Questo passaggio utilizza una ricerca avida locale che percorre in modo casuale la stringa della soluzione e inverte i valori dei bit se ciò riduce il valore della funzione di costo.

Benchmark

Modello di Sherrington-Kirkpatrick

La figura 2 illustra l'efficacia del Parity Twine Optimizer. Qui vengono messi a confronto i risultati ottenuti utilizzando l'ottimizzatore con quelli ottenuti tramite campionamento casuale per il modello di Sherrington-Kirkpatrick con un numero crescente di qubit.

La post-elaborazione sia dei risultati casuali che di quelli ottenuti con l'ottimizzatore porta a stati fondamentali esatti, ma il valore grezzo dell'energia minima fornito da Twine QAOA è sempre migliore rispetto ai valori casuali. Per i numeri più elevati di qubit considerati (90 e 100), il rumore dell’hardware compromette il risultato dell’ottimizzatore, che torna a valori grezzi corrispondenti al campionamento casuale.

Consulta questo tutorial per un'introduzione al modello di Sherrington-Kirkpatrick e per informazioni dettagliate su come risolverlo con il Parity Twine Optimizer.

Problema di frammentazione del mercato

La tabella 1 mostra gli indicatori di prestazione specifici dell'ottimizzatore Parity Twine applicato a varie istanze del problema della suddivisione del mercato (MS). Questi dati sono stati ricavati dalla QOBLIB (Quantum Optimization Benchmarking Library) e corrispondono alle proposte inviate alla libreria utilizzando il Parity Twine Optimizer.

La violazione MS è una metrica di accuratezza che misura quanto la soluzione sia lontana dal soddisfare tutti i vincoli, definita come $\sum_i ((Ax - b)_i)^2$. Valori più bassi di questa metrica indicano soluzioni più accurate. La tabella 1 riporta i valori medi relativi a cinque esecuzioni di ciascuna istanza ottenute utilizzando il Parity Twine Optimizer con il dispositivo ibm_boston come backend e 100.000 shot. Viene riportata la violazione minima di MS ottenuta dalle esecuzioni di ciascuna istanza.

Tabella 1: Indicatori di prestazione per diverse istanze del problema della suddivisione del mercato. I nomi delle istanze si riferiscono agli esempi corrispondenti presenti nella libreria di problemi QOBLIB. Come già menzionato nella sezione dedicata alla descrizione, il tempo di elaborazione della QPU è minimo e pressoché costante, poiché viene utilizzato un solo ciclo di QAOA con parametri circuitali ottimali ottenuti su una CPU.

Consulta questo tutorial per un'introduzione al problema della suddivisione del mercato e per maggiori dettagli su come risolverlo con il Parity Twine Optimizer.

Problema dell'insieme indipendente massimo

La figura 3 mette a confronto i risultati ottenuti utilizzando l'ottimizzatore Parity Twine con quelli ottenuti tramite campionamento casuale per il problema dell'insieme indipendente massimo su istanze selezionate tratte dalla QOBLIB (Quantum Optimization Benchmarking Library). Questi vanno da 18 (interazioni tra mammiferi e canguri) a 114 ( es60fst03 ) qubit.

Per le istanze di piccole dimensioni, la dimensione massima dell’insieme indipendente ottenuta dall’ottimizzatore e quella ottenuta tramite campionamento casuale sono simili, ma per le istanze più grandi l’ottimizzatore fornisce risultati di gran lunga migliori. La post-elaborazione sia dei risultati ottenuti tramite campionamento casuale sia di quelli ottenuti con l'ottimizzatore porta nuovamente a dimensioni degli insiemi in accordo con i valori esatti.

Introduzione

Effettua l'autenticazione utilizzando il tuo token API di IBM Quantum Platform e seleziona la funzione Qiskit come:

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

Esempio

L'ottimizzatore Parity Twine può essere applicato a un semplice esempio QUBO come segue. Il problema viene innanzitutto definito utilizzando un dizionario:

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

Quindi, il tipo della variabile deve essere definito come binary o spin:

variable_type = "spin"

Ciò definisce la funzione obiettivo $3 + s_0 + 2 s_0s_1 - s_1s_2$, dove $s_i \in \{-1, 1\}$.

Scegli un backend. Ad esempio:

backend_name = "ibm_phoenix"

Utilizza catalog.backends() per visualizzare l'elenco dei backend disponibili dall'account utente/istanza.

Se non viene specificato alcun backend, viene selezionato automaticamente il backend meno carico (quello con il minor numero di lavori in sospeso).

Una volta caricato l'ottimizzatore (vedi sopra), è possibile eseguirlo sul problema utilizzando le opzioni predefinite:

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

Verifica lo stato del lavoro come segue:

# Monitor the job status
function_job.status()

Recuperare i risultati come segue:

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

result

Stampando i risultati si ottiene quanto segue:

{
    '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}
        }
    }
}

Il dizionario solution corrisponde ai qubit definiti nel problema ( $s_0, s_1$ e $s_2$ ) e fornisce i valori ottimizzati dei loro spin.

Il rappresenta objective_value il costo o l'energia del problema di ottimizzazione. Quantifica la qualità solution .

metadata fornisce informazioni sulla transpilazione (numero di gate a due qubit/profondità, gate utilizzati, qubit attivi) e sui vari tempi di esecuzione sia per il calcolo quantistico che per quello classico.

Inoltre, metadata offre uno sguardo sui meccanismi interni dell'algoritmo. È possibile visualizzare i parametri variazionali ottimizzati (beta e gamma) e verificare come sia migliorata la distribuzione delle stringhe di bit misurate dopo l’applicazione della post-elaborazione classica ai risultati quantistici grezzi.

Tutte le stringhe di bit presenti nell'output dei risultati possono essere mappate alle variabili del problema utilizzando il variable_mapping. Ad esempio, è possibile associare il 'solution_bitstring': '100' al 'variable_mapping': {'0': 0, '1': 1, '2': 2} nella soluzione binaria: {'0': 1, '1': 0, '2': 0}. Poiché stai risolvendo il problema in termini di variabili di spin, devi applicare la trasformazione da binario a spin (0 -> 1, 1 -> -1 ). Si ottiene così la soluzione finale 'solution': {'0': -1, '1': 1, '2': 1}.

Per informazioni complete sugli input e sugli output della funzione Parity Twine Optimizer, consultare la documentazione di riferimento dell'API.

Changelog

[1.0.2] - 15 settembre 2026

Note

Questa versione rappresenta la prima versione stabile e definitiva della funzione Qiskit "Parity Twine Optimizer". Si prevede che le prossime versioni includano le seguenti novità:

• compilazione di problemi di ordine superiore,
• ulteriori algoritmi di ottimizzazione, e
• miglioramenti nella fase di pre-elaborazione e post-elaborazione.

Funzioni

• Risolvi problemi QUBO sparsi e densi con l’efficiente Parity Twine Compiler.

Documentazione

• Guida introduttiva per l'utente.
• Tutorial con esempi relativi alla suddivisione del mercato e ai problemi di Sherrington-Kirkpatrick.
• Documentazione API.

Ottenere supporto

Per qualsiasi domanda o problema, contatta ParityQC.

Passi successivi