Creare ed eseguire un modello di funzione Qiskit per la simulazione della struttura elettronica con un modello a solvente implicito

Questo modello, sviluppato in collaborazione con la Cleveland Clinic, consiste in un flusso di lavoro per calcolare l'energia di stato fondamentale e l'energia libera di solvatazione di una molecola in un solvente implicito [1]. Queste simulazioni si basano sul metodo della diagonalizzazione quantistica basata sui campioni (SQD) [2-6] e sul modello continuo polarizzabile a equazione integrale (IEF-PCM) del solvente [7].

Per una guida dettagliata passo dopo passo su questo stesso flusso di lavoro con un esempio pratico, consultare il tutorial “Calcoli con solvente implicito utilizzando Qiskit Serverless ”.

Questa guida utilizza il modello con una molecola di metanolo come soluto, la cui struttura elettronica è simulata esplicitamente, e l'acqua come solvente, approssimata come un mezzo dielettrico continuo. Per tenere conto degli effetti di correlazione degli elettroni nel metanolo, mantenendo l'equilibrio tra costo computazionale e accuratezza, includiamo solo gli orbitali $\sigma$ , $\sigma^{*}$ , e la coppia solitaria nello spazio attivo simulato con SQD IEF-PCM. La selezione degli orbitali viene effettuata con il metodo dello spazio attivo di valenza atomica (AVAS) utilizzando le componenti degli orbitali atomici [C2s,2p], O2s[,2p] e [H1s], che danno come risultato uno spazio attivo di 14 elettroni e 12 orbitali ( 14e,12o ). Gli orbitali di riferimento sono calcolati con Hartree Fock a guscio chiuso utilizzando il set di basi cc-pvdz.

Introduzione al flusso di lavoro

Questa guida interattiva mostra come caricare questo modello di funzione su Qiskit Serverless ed eseguire un carico di lavoro di esempio. Il modello è strutturato come uno schema Qiskit con quattro fasi:

1. Raccogliere informazioni e mappare il problema

Questa fase prende in input la geometria della molecola, lo spazio attivo selezionato, il modello di solvatazione, le opzioni LUCJ e SQD. Quindi produce il file PySCF Checkpoint, che contiene i dati Hartree-Fock (HF) IEF-PCM. Questi dati saranno utilizzati nella parte SQD del flusso di lavoro. Per la parte LUCJ del flusso di lavoro, la sezione di input genera anche i dati HF in fase gassosa, memorizzati internamente nel formato PySCF FCIDUMP.

Le informazioni della simulazione HF in fase gassosa e la definizione dello spazio attivo sono prese come input. Inoltre, utilizza le informazioni definite dall'utente nella sezione di input relative alla soppressione degli errori, al numero di scatti, al livello di ottimizzazione del transpiler del circuito e alla disposizione dei qubit.

Genera integrali di un elettrone e due elettroni all'interno dello spazio attivo definito. Gli integrali vengono poi utilizzati per eseguire calcoli CCSD classici, che restituiscono t2 ampiezze che utilizziamo per parametrizzare il circuito LUCJ.

2. Ottimizzare il circuito

Il circuito LUCJ viene quindi tradotto in un circuito ISA per l'hardware di destinazione. Viene quindi istanziata una primitiva Sampler con un insieme predefinito di opzioni di attenuazione degli errori per gestire l'esecuzione.

3. Eseguire il circuito

I calcoli LUCJ restituiscono i bitstring per ogni misura, dove questi bitstring corrispondono alle configurazioni degli elettroni del sistema studiato. Le stringhe di bit vengono quindi utilizzate come input per la post-elaborazione.

4. Post-elaborazione utilizzando SQD

Questa fase finale prende come input il file PySCF Checkpoint contenente le informazioni HF IEF-PCM, i bitstring che rappresentano le configurazioni degli elettroni previste da LUCJ e le opzioni SQD definite dall'utente e selezionate nella sezione input. Come output, produce l'energia totale SQD IEF-PCM del batch a più bassa energia e la corrispondente energia libera di solvatazione.

Opzioni

Per questo modello è necessario specificare le opzioni per la generazione del circuito LUCJ e i parametri di esecuzione SQD.

Opzioni LUCJ

Quando il circuito quantistico LUCJ viene eseguito, viene prodotto un insieme di campioni che rappresentano gli stati base computazionali della distribuzione di probabilità del sistema molecolare. Per bilanciare la profondità del circuito LUCJ e la sua esprimibilità, i qubit corrispondenti agli orbitali di spin opposto hanno i gate a due qubit applicati tra loro quando questi qubit sono vicini attraverso un singolo qubit ancilla. Per implementare questo approccio sull'hardware IBM con una topologia heavy-hex, i qubit che rappresentano gli orbitali di spin con lo stesso spin sono collegati attraverso una topologia a linee in cui ogni linea assume una forma a zig-zag a causa della connettività heavy-hex dell'hardware di destinazione, mentre i qubit che rappresentano gli orbitali di spin opposto hanno una connessione solo ogni quarto qubit.

L'utente deve fornire l'array initial_layout corrispondente ai qubit che soddisfano questo schema a zig-zag nella sezione lucj_options della funzione SQD IEF-PCM. Nel caso delle simulazioni SQD IEF-PCM ( 14e,12o )/cc-pvdz del metanolo, abbiamo scelto la disposizione iniziale dei qubit corrispondente alla diagonale principale del QPU Eagle R3. Qui, i primi 12 elementi della matrice initial_layout [0, 14, 18, 19, 20, 33, 39, 40, 41, 53, 60, 61, ...] corrispondono agli orbitali di spin alfa. Gli ultimi 12 elementi [... 2, 3, 4, 15, 22, 23, 24, 34, 43, 44, 45, 54] corrispondono agli orbitali di spin beta.
È importante che l'utente determini il valore number_of_shots, che corrisponde al numero di misure nel circuito LUCJ. Il numero di scatti deve essere sufficientemente grande perché il primo passo della procedura S-CORE si basa sui campioni del settore destro delle particelle per ottenere l'approssimazione iniziale alla distribuzione del numero di occupazione del ground-state.
Il numero di scatti dipende fortemente dal sistema e dall'hardware, ma gli studi SQD non covalenti, basati sui frammenti e sui solventi impliciti suggeriscono che si può raggiungere l'accuratezza chimica seguendo queste linee guida:
- 20.000 - 200.000 scatti per sistemi con meno di 16 orbitali molecolari (32 orbitali di spin)
- 200.000 scatti per sistemi con 16-18 orbitali molecolari
- 200.000 - 2.000.000 di scatti per sistemi con più di 18 orbitali molecolari
Il numero di simulazioni richiesto dipende dal numero di orbitali di spin nel sistema in esame e dalle dimensioni dello spazio di Hilbert corrispondente allo spazio attivo selezionato all'interno del sistema in esame. In generale, le istanze con spazi di Hilbert più piccoli richiedono un numero minore di iterazioni. Altre opzioni disponibili in LUCJ sono il livello di ottimizzazione del transpiler di circuiti e le opzioni di soppressione degli errori. Si noti che queste opzioni influiscono anche sul numero di scatti necessari e sulla precisione risultante.

Opzioni SQD

Tra le opzioni importanti nelle simulazioni SQD ci sono sqd_iterations, number_of_batches e samples_per_batch. In generale, il numero inferiore di campioni per lotto può essere compensato con più lotti (number_of_batches) e più iterazioni di S-CORE (sqd_iterations). Con più lotti possiamo campionare più variazioni dei sottospazi configurazionali. Poiché il batch a più bassa energia viene preso come soluzione per l'energia di stato fondamentale del sistema, un numero maggiore di batch può migliorare i risultati grazie a statistiche migliori. Ulteriori iterazioni di S-CORE consentono di recuperare più configurazioni dalla distribuzione LUCJ originale se il numero di campioni nel settore corretto delle particelle è basso. Ciò può consentire di ridurre il numero di campioni per lotto.

Una strategia alternativa consiste nell'utilizzare più campioni per lotto, in modo da garantire che la maggior parte dei campioni LUCJ iniziali nel giusto spazio delle particelle venga utilizzata durante la procedura S-CORE e che i singoli sottospazi incapsulino una varietà sufficiente di configurazioni di elettroni. A sua volta, questo riduce il numero di passaggi S-CORE richiesti, dove sono necessarie solo due o tre iterazioni di SQD se il numero di campioni per lotto è sufficientemente grande. Tuttavia, un numero maggiore di campioni per lotto comporta un costo computazionale più elevato per ogni fase di diagonalizzazione. Pertanto, l'equilibrio tra precisione e costo computazionale nelle simulazioni SQD può essere raggiunto scegliendo in modo ottimale sqd_iterations, number_of_batches e samples_per_batch .
Lo studio SQD IEF-PCM mostra che quando si utilizzano tre iterazioni di S-CORE, è possibile raggiungere l'accuratezza chimica seguendo queste linee guida:
- 600 campioni per lotto in metanolo Simulazioni SQD IEF-PCM ( 14e,12o )
- 1500 campioni per lotto in simulazioni di metilammina SQD IEF-PCM ( 14e,13o )
- 6000 campioni per lotto in acqua Simulazioni SQD IEF-PCM ( 8e,23o )
- 16000 campioni per lotto in etanolo Simulazioni SQD IEF-PCM ( 20e,18o )
Proprio come il numero di scatti richiesto in LUCJ, il numero di campioni per lotto richiesto nella procedura S-CORE dipende fortemente dal sistema e dall'hardware. Gli esempi sopra riportati possono essere utilizzati per stimare il punto iniziale per il benchmark del numero di campioni richiesto per lotto. Il tutorial sul benchmark sistematico del numero necessario di campioni per lotto è disponibile qui.

Distribuire ed eseguire la funzione SQD IEF-PCM del modello

Autenticazione

Utilizzate qiskit-ibm-catalog per autenticarvi a QiskitServerless con la vostra chiave API (token), che si trova nella dashboard di IBM Quantum Platform. Ciò consente l'istanziazione del client serverless per caricare o eseguire la funzione selezionata:

from qiskit_ibm_catalog import QiskitServerless

serverless = QiskitServerless(
    channel="ibm_quantum_platform",
    instance="INSTANCE_CRN",
    # For `token`, use the 44-character API_KEY you created
    # and saved from the IBM Quantum Platform Home dashboard
    token="YOUR_API_KEY"
)

Opzionalmente, si può usare save_account() per salvare le credenziali in un ambiente locale (vedere la guida Impostare l'account IBM Cloud ). Si noti che questo scrive le credenziali nello stesso file di QiskitRuntimeService.save_account():

QiskitServerless.save_account(token="YOUR_API_KEY",
    channel="ibm_quantum_platform", instance="INSTANCE_CRN")

Se l 'account è salvato, non è necessario fornire il token per l'autenticazione:

from qiskit_ibm_catalog import QiskitServerless

serverless = QiskitServerless()

Carica il modello

Per caricare una funzione Qiskit personalizzata, è necessario prima istanziare un oggetto QiskitFunction che definisce il codice sorgente della funzione. Il titolo consentirà di identificare la funzione una volta inserita nel cluster remoto. Il punto di ingresso principale è il file che contiene if __name__ == "__main__". Se il flusso di lavoro richiede file di origine aggiuntivi, è possibile definire una directory di lavoro che verrà caricata insieme al punto di ingresso.

from qiskit_ibm_catalog import QiskitFunction

template = QiskitFunction(
    title="sqd_pcm_template",
    entrypoint="sqd_pcm_entrypoint.py",
    # all files in `working_dir` will be uploaded
    working_dir="./source_files/",
    dependencies=[
        "ffsim==0.0.54",
        "pyscf==2.9.0",
        "qiskit_addon_sqd==0.10.0",
    ],
)
print(template)

Output:

QiskitFunction(sqd_pcm_template)

Una volta che l'istanza è pronta, caricarla su serverless:

serverless.upload(template)

Output:

QiskitFunction(sqd_pcm_template)

Per verificare se il programma è stato caricato con successo, utilizzare serverless.list():

serverless.list()

Output:

[QiskitFunction(sqd_pcm_template),
 QiskitFunction(hamiltonian_simulation_template)]

Caricare ed eseguire il modello in remoto

Il modello di funzione è stato caricato, quindi è possibile eseguirlo in remoto con Qiskit Serverless. Per prima cosa, caricare il modello per nome:

template = serverless.load("sqd_pcm_template")
print(template)

Output:

QiskitFunction(sqd_pcm_template)

Quindi, eseguire il modello con gli ingressi a livello di dominio per SQD-IEF PCM. Questo esempio specifica un carico di lavoro a base di metanolo.

molecule = {
    "atom": """
    O -0.04559 -0.75076 -0.00000;
    C -0.04844 0.65398 -0.00000;
    H 0.85330 -1.05128 -0.00000;
    H -1.08779 0.98076 -0.00000;
    H 0.44171 1.06337 0.88811;
    H 0.44171 1.06337 -0.88811
    """,  # Must be specified
    "basis": "cc-pvdz",  # default is "sto-3g"
    "spin": 0,  # default is 0
    "charge": 0,  # default is 0
    "verbosity": 0,  # default is 0
    "number_of_active_orb": 12,  # Must be specified
    "number_of_active_alpha_elec": 7,  # Must be specified
    "number_of_active_beta_elec": 7,  # Must be specified
    "avas_selection": [
        "%d O %s" % (k, x) for k in [0] for x in ["2s", "2px", "2py", "2pz"]
    ]
    + ["%d C %s" % (k, x) for k in [1] for x in ["2s", "2px", "2py", "2pz"]]
    + ["%d H 1s" % k for k in [2, 3, 4, 5]],  # default is None
}

solvent_options = {
    # See https://manual.q-chem.com/5.4/topic_pcm-em.html for all methods
    "method": "IEF-PCM",  # other available methods are COSMO, C-PCM, SS(V)PE
    "eps": 78.3553,  # value for water
}

lucj_options = {
    "initial_layout": [
        0,
        14,
        18,
        19,
        20,
        33,
        39,
        40,
        41,
        53,
        60,
        61,
        2,
        3,
        4,
        15,
        22,
        23,
        24,
        34,
        43,
        44,
        45,
        54,
    ],
    "dynamical_decoupling_choice": True,
    "twirling_choice": True,
    "number_of_shots": 200000,
    "optimization_level": 2,
}

sqd_options = {
    "sqd_iterations": 3,
    "number_of_batches": 10,
    "samples_per_batch": 1000,
    "max_davidson_cycles": 200,
}

backend_name = "ibm_sherbrooke"

job = template.run(
    backend_name=backend_name,
    molecule=molecule,
    solvent_options=solvent_options,
    lucj_options=lucj_options,
    sqd_options=sqd_options,
)
print(job.job_id)

Output:

39f8fb70-79b2-43ca-b723-84e6b6135821

Controllare lo stato dettagliato del lavoro:

import time

t0 = time.time()
status = job.status()
if status == "QUEUED":
    print(f"time = {time.time()-t0:.2f}, status = QUEUED")
while True:
    status = job.status()
    if status == "QUEUED":
        continue
    print(f"time = {time.time()-t0:.2f}, status = {status}")
    if status == "DONE" or status == "ERROR":
        break

Output:

time = 2.35, status = DONE

Mentre il lavoro è in esecuzione, è possibile recuperare i registri creati dagli output di logger.info . Questi possono fornire informazioni utili sull'avanzamento del flusso di lavoro SQD IEF-PCM. Ad esempio, le stesse connessioni degli orbitali di spin, o la profondità di due qubit del circuito ISA finale destinato all'esecuzione su hardware.

print(job.logs())

La richiesta del risultato del lavoro blocca il resto del programma finché non è disponibile un risultato. Al termine del lavoro, è possibile recuperare i risultati. Queste includono l'energia libera di solvatazione, nonché informazioni sul lotto a più bassa energia, sul valore energetico più basso e altre informazioni utili come la durata totale del solutore.

result = job.result()

result

Output:

{'total_energy_hist': array([[-115.14768518, -115.1368396 , -114.19181692, -115.13745429,
         -115.1445012 , -114.19673326, -115.1547003 , -114.20563866,
         -115.13748344, -115.14764974],
        [-115.15768392, -115.15850126, -115.15857275, -115.15770916,
         -115.15801684, -115.15822125, -115.15833521, -115.15844051,
         -115.15735538, -115.15862354],
        [-115.15795148, -115.15847925, -115.15856677, -115.15811156,
         -115.15815602, -115.15785171, -115.1583672 , -115.1585533 ,
         -115.15833528, -115.15808791]]),
 'spin_squared_value_hist': array([[5.37327508e-03, 1.32981759e-02, 1.36214922e-02, 8.84413615e-03,
         7.26723578e-03, 1.94875195e-02, 3.03153152e-03, 6.07543106e-03,
         1.04951849e-02, 5.36529204e-03],
        [6.39397528e-04, 1.36814350e-04, 9.09054260e-05, 5.99361358e-04,
         3.64261739e-04, 2.54905866e-04, 2.32540370e-04, 1.53181990e-04,
         7.23519739e-04, 6.80737671e-05],
        [4.53776416e-04, 1.63043449e-04, 1.05317263e-04, 3.82912836e-04,
         3.41047803e-04, 5.18620393e-04, 2.06819142e-04, 1.17086537e-04,
         2.32357159e-04, 4.26071537e-04]]),
 'solvation_free_energy_hist': array([[-0.00725018, -0.00743955, -0.01132905, -0.0073377 , -0.00722221,
         -0.01136705, -0.00719279, -0.01072829, -0.00733404, -0.00725961],
        [-0.00719252, -0.00718315, -0.00718074, -0.00719325, -0.00717703,
         -0.00718391, -0.00718354, -0.00717928, -0.00719887, -0.0071801 ],
        [-0.00719351, -0.00718255, -0.00718198, -0.00718429, -0.00718349,
         -0.00718329, -0.0071882 , -0.00718363, -0.00718549, -0.00718814]]),
 'occupancy_hist': [[array([0.99712298, 0.99278936, 0.99083163, 0.97328469, 0.98959809,
          0.98922134, 0.720333  , 0.25683194, 0.01939338, 0.02840332,
          0.00946988, 0.0327204 ]),
   array([0.99712298, 0.99278936, 0.99083163, 0.97328469, 0.98959809,
          0.98922134, 0.720333  , 0.25683194, 0.01939338, 0.02840332,
          0.00946988, 0.0327204 ])],
  [array([0.9959042 , 0.9922607 , 0.99018862, 0.99265843, 0.98927447,
          0.9900833 , 0.99403876, 0.00989025, 0.01120814, 0.01137717,
          0.01152871, 0.01158725]),
   array([0.9959042 , 0.9922607 , 0.99018862, 0.99265843, 0.98927447,
          0.9900833 , 0.99403876, 0.00989025, 0.01120814, 0.01137717,
          0.01152871, 0.01158725])],
  [array([0.99590079, 0.99222193, 0.99016753, 0.99265045, 0.98927264,
          0.99007179, 0.99407207, 0.00986684, 0.01125181, 0.01141439,
          0.01150733, 0.01160243]),
   array([0.99590079, 0.99222193, 0.99016753, 0.99265045, 0.98927264,
          0.99007179, 0.99407207, 0.00986684, 0.01125181, 0.01141439,
          0.01150733, 0.01160243])]],
 'lowest_energy_batch': 2,
 'lowest_energy_value': -115.1585667736213,
 'solvation_free_energy': -0.007181981952470838,
 'sci_solver_total_duration': 493.997501373291,
 'metadata': {'resources_usage': {'RUNNING: MAPPING': {'CPU_TIME': 6.080063343048096},
   'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 1.999896764755249},
   'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 6.2850868701934814},
   'RUNNING: EXECUTING_QPU': {'QPU_TIME': 21.639373540878296},
   'RUNNING: POST_PROCESSING': {'CPU_TIME': 495.40831995010376}},
  'num_iterations_executed': 3}}

Si noti che i metadati dei risultati includono un riepilogo dell'utilizzo delle risorse che consente di stimare meglio il tempo della QPU e della CPU richiesto per ciascun carico di lavoro (questo esempio è stato eseguito su un dispositivo fittizio, quindi i tempi di utilizzo effettivi delle risorse potrebbero essere diversi).

Al termine del lavoro, sarà disponibile l'intero output di registrazione.

print(job.logs())

Output:

2025-06-27 08:42:41,358	INFO job_manager.py:531 -- Runtime env is setting up.
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:45,015: Starting runtime service
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:45,621: Backend: ibm_sherbrooke
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:46,809: Initializing molecule object
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:51,599: Performing CCSD
Parsing /tmp/ray/session_2025-06-27_08-42-13_898146_1/runtime_resources/working_dir_files/_ray_pkg_4bc93dcc58c04b91/output_sqd_pcm/2025-06-27_08-42-45.fcidump.txt
Overwritten attributes  get_ovlp get_hcore  of <class 'pyscf.scf.hf_symm.SymAdaptedRHF'>
/usr/local/lib/python3.11/site-packages/pyscf/gto/mole.py:1293: UserWarning: Function mol.dumps drops attribute energy_nuc because it is not JSON-serializable
  warnings.warn(msg)
/usr/local/lib/python3.11/site-packages/pyscf/gto/mole.py:1293: UserWarning: Function mol.dumps drops attribute intor_symmetric because it is not JSON-serializable
  warnings.warn(msg)
converged SCF energy = -115.049680672847
E(CCSD) = -115.1519910037652  E_corr = -0.1023103309180226
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:51,694: Same spin orbital connections: [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10), (10, 11)]
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:51,694: Opposite spin orbital connections: [(0, 0), (4, 4), (8, 8)]
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:53,718: Optimization level: 2, ops: OrderedDict([('rz', 2438), ('sx', 1496), ('ecr', 766), ('x', 185), ('measure', 24), ('barrier', 1)]), depth: 391
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:53,736: Two-qubit gate depth: 94
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:53,737: Submitting sampler job
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:54,273: Job ID: d1f5j3lqbivc73ebqpj0
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:54,313: Job Status: QUEUED
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,813: Starting configuration recovery iteration 0
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,841: Batch 0 subspace dimension: 531441
2025-06-27 08:43:24,844	INFO worker.py:1588 -- Using address 172.17.16.124:6379 set in the environment variable RAY_ADDRESS
2025-06-27 08:43:24,847	INFO worker.py:1723 -- Connecting to existing Ray cluster at address: 172.17.16.124:6379...
2025-06-27 08:43:24,876	INFO worker.py:1908 -- Connected to Ray cluster. View the dashboard at [1m[32mhttp://172.17.16.124:8265 [39m[22m
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,945: Batch 1 subspace dimension: 519841
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,950: Batch 2 subspace dimension: 543169
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,955: Batch 3 subspace dimension: 532900
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,960: Batch 4 subspace dimension: 534361
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,964: Batch 5 subspace dimension: 531441
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,969: Batch 6 subspace dimension: 540225
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,974: Batch 7 subspace dimension: 524176
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,979: Batch 8 subspace dimension: 537289
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,983: Batch 9 subspace dimension: 540225
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:09,006: Lowest energy batch: 6
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:09,007: Lowest energy value: -115.15470029849135
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:09,007: Corresponding g_solv value: -0.0071927910374866375
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:09,007: -----------------------------------
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:09,007: Starting configuration recovery iteration 1
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,564: Batch 0 subspace dimension: 413449
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,572: Batch 1 subspace dimension: 399424
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,578: Batch 2 subspace dimension: 438244
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,583: Batch 3 subspace dimension: 422500
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,589: Batch 4 subspace dimension: 409600
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,596: Batch 5 subspace dimension: 404496
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,601: Batch 6 subspace dimension: 410881
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,605: Batch 7 subspace dimension: 442225
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,611: Batch 8 subspace dimension: 409600
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,618: Batch 9 subspace dimension: 405769
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:49:54,917: Lowest energy batch: 9
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:49:54,917: Lowest energy value: -115.15862353596414
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:49:54,917: Corresponding g_solv value: -0.0071800982859467006
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:49:54,918: -----------------------------------
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:49:54,918: Starting configuration recovery iteration 2
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,501: Batch 0 subspace dimension: 399424
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,508: Batch 1 subspace dimension: 412164
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,514: Batch 2 subspace dimension: 432964
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,519: Batch 3 subspace dimension: 400689
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,524: Batch 4 subspace dimension: 432964
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,529: Batch 5 subspace dimension: 418609
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,533: Batch 6 subspace dimension: 418609
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,538: Batch 7 subspace dimension: 425104
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,543: Batch 8 subspace dimension: 404496
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,548: Batch 9 subspace dimension: 429025
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:51:37,900: Lowest energy batch: 2
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:51:37,900: Lowest energy value: -115.1585667736213
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:51:37,901: Corresponding g_solv value: -0.007181981952470838
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:51:37,901: -----------------------------------
sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:51:37,901: SCI_solver totally takes: 493.997501373291 seconds

Cita questo progetto

Se utilizzate il modello SQD IEF-PCM nella vostra ricerca, vi preghiamo di consultare l 'archivio per informazioni dettagliate sulla citazione.

Passi successivi

Suggerimenti

Segui il tutorial “Calcoli del solvente implicito utilizzando l’ Qiskit Serverless ” per un esempio pratico di questo stesso flusso di lavoro
Consulta la guida sulla creazione di un modello di funzione per la simulazione hamiltoniana
Consultate i file sorgenti di questo modello su GitHub

Riferimenti

[1] Danil Kaliakin, Akhil Shajan, Fangchun Liang e Kenneth M. Merz Jr. Implicit Solvent Sample-Based Quantum Diagonalization, The Journal of Physical Chemistry B, 2025, DOI: 10.1021/acs.jpcb.5c01030

[2] Javier Robledo-Moreno, et al, Chemistry Beyond Exact Solutions on a Quantum-Centric Supercomputer, arXiv:2405.05068 [quant-ph].

[3] Jeffery Yu, et al, Algoritmo quantistico per la diagonalizzazione di Krylov basata su campioni, arXiv:2501.09702 [quant-ph].

[4] Keita Kanno, et al, Quantum-Selected Configuration Interaction: classical diagonalization of Hamiltonians in subspaces selected by quantum computers, arXiv:2302.11320 [quant-ph].

[5] Kenji Sugisaki, et al, Interazione di configurazione quantistica selezionata basata sulla simulazione hamiltoniana per calcoli di struttura elettronica su larga scala con un computer quantistico, arXiv:2412.07218 [quant-ph].

[6] Mathias Mikkelsen, Yuya O. Nakagawa, Quantum-selected configuration interaction with time-evolved state, arXiv:2412.13839 [quant-ph].

[7] Herbert, John M. Metodi di continuum dielettrico per la chimica quantistica. WIREs Computational Molecular Science, 2021, 11, 1759-0876.

[8] Saki, A. A.; Barison, S.; Fuller, B.; Garrison, J. R.; Glick, J. R.; Johnson, C.; Mezzacapo, A.; Robledo-Moreno, J.; Rossmannek, M.; Schweigert, P. et al. Addon Qiskit: diagonalizzazione quantistica basata su campioni, 2024; https://github.com/Qiskit/qiskit-addon-sqd

[9] Asun, Q.; Zhang, X.; Banerjee, S.; Bao, P.; Barbry, M.; Blunt, N. S.; Bogdanov, N. A.; Booth, G. H.; Chen, J.; Cui, Z.-H. PySCF: Python -simulazioni basate sul quadro chimico, 2025; https://github.com/pyscf/pyscf

[10] Kevin J. Sung; et al., FFSIM: simulazioni più veloci di circuiti quantistici fermionici, 2024. https://github.com/qiskit-community/ffsim

Questa pagina è stata utile?

Segnala un bug, un errore di battitura o richiedi contenuti su GitHub.