{
"cells": [
{
"cell_type": "markdown",
"id": "8cfa587b",
"metadata": {},
"source": [
"---\n",
"title: \"Creare una funzione Qiskit per la simulazione chimica\"\n",
"description: \"Scopri come implementare ed eseguire il modello di flusso di lavoro chimico\"\n",
"---\n",
"\n",
"\n",
"\n",
"# Creare ed eseguire un modello di funzione Qiskit per la simulazione della struttura elettronica con un modello a solvente implicito\n",
"\n",
"{/* cspell:ignore pvdz, fcisolver, avas, ncas, nelecas, ecore, chkfile, fcivec, hcore, ncore, myci, sqdvec, myeps, mymethod, mysolvmethod, myavas, mcscf, MCSCF, chkfile, prqs */}\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "f9bfec87",
"metadata": {
"tags": [
"version-info"
]
},
"source": [
"\n"
]
},
{
"cell_type": "markdown",
"id": "f3a337d1",
"metadata": {},
"source": [
"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\\]](#references). Queste simulazioni si basano sul metodo della diagonalizzazione quantistica basata sui campioni (SQD) [\\[2-6\\]](#references) e sul modello continuo polarizzabile a equazione integrale (IEF-PCM) del solvente [\\[7\\]](#references).\n",
"\n",
"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](/docs/tutorials/implicit-solvent-calculations) ”.\n",
"\n",
"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](https://onlinelibrary.wiley.com/doi/epdf/10.1002/ijch.202100111) 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)](https://github.com/pyscf/pyscf.github.io/blob/master/examples/mcscf/43-avas.py) 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.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "25d18ba5",
"metadata": {},
"source": [
"\n",
"\n",
"## Introduzione al flusso di lavoro\n",
"\n",
"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:\n",
"\n",
"\n",
"\n",
"#### 1. Raccogliere informazioni e mappare il problema\n",
"\n",
"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.\n",
"\n",
"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.\n",
"\n",
"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.\n",
"\n",
"\n",
"\n",
"#### 2. Ottimizzare il circuito\n",
"\n",
"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.\n",
"\n",
"\n",
"\n",
"#### 3. Eseguire il circuito\n",
"\n",
"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.\n",
"\n",
"\n",
"\n",
"#### 4. Post-elaborazione utilizzando SQD\n",
"\n",
"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.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "4832ef18",
"metadata": {},
"source": [
"\n",
"\n",
"### Opzioni\n",
"\n",
"Per questo modello è necessario specificare le opzioni per la generazione del circuito LUCJ e i parametri di esecuzione SQD.\n",
"\n",
"\n",
"\n",
"#### Opzioni LUCJ\n",
"\n",
"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.\n",
"\n",
"\n",
" \n",
" L'utente deve fornire l'array `initial_layout` corrispondente ai qubit che soddisfano questo [schema *a zig-zag*](https://pubs.rsc.org/en/content/articlehtml/2023/sc/d3sc02516k) 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.\n",
"\n",
" È 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.\n",
"\n",
" Il numero di scatti dipende fortemente dal sistema e dall'hardware, ma gli studi SQD [non covalenti](https://arxiv.org/abs/2410.09209), [basati sui frammenti](https://arxiv.org/abs/2411.09861) e sui [solventi impliciti](https://pubs.acs.org/doi/10.1021/acs.jpcb.5c01030) suggeriscono che si può raggiungere l'accuratezza chimica seguendo queste linee guida:\n",
"\n",
" * 20.000 - 200.000 scatti per sistemi con meno di 16 orbitali molecolari (32 orbitali di spin)\n",
" * 200.000 scatti per sistemi con 16-18 orbitali molecolari\n",
" * 200.000 - 2.000.000 di scatti per sistemi con più di 18 orbitali molecolari\n",
"\n",
" 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](https://docs.quantum.ibm.com/guides/set-optimization) e [le opzioni di soppressione degli errori](https://docs.quantum.ibm.com/guides/error-mitigation-and-suppression-techniques). Si noti che queste opzioni influiscono anche sul numero di scatti necessari e sulla precisione risultante.\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "e2b46498",
"metadata": {},
"source": [
"\n",
"\n",
"#### Opzioni SQD\n",
"\n",
"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.\n",
"\n",
"\n",
" \n",
" 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` .\n",
"\n",
" Lo [studio SQD IEF-PCM](https://pubs.acs.org/doi/10.1021/acs.jpcb.5c01030) mostra che quando si utilizzano tre iterazioni di S-CORE, è possibile raggiungere l'accuratezza chimica seguendo queste linee guida:\n",
"\n",
" * 600 campioni per lotto in metanolo Simulazioni SQD IEF-PCM ( 14e,12o )\n",
" * 1500 campioni per lotto in simulazioni di metilammina SQD IEF-PCM ( 14e,13o )\n",
" * 6000 campioni per lotto in acqua Simulazioni SQD IEF-PCM ( 8e,23o )\n",
" * 16000 campioni per lotto in etanolo Simulazioni SQD IEF-PCM ( 20e,18o )\n",
"\n",
" 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](https://qiskit.github.io/qiskit-addon-sqd/how_tos/choose_subspace_dimension.html).\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "998a0f25",
"metadata": {},
"source": [
"\n",
"\n",
"## Distribuire ed eseguire la funzione SQD IEF-PCM del modello\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "6c92ac84",
"metadata": {
"vscode": {
"languageId": "plaintext"
}
},
"source": [
"\n",
"\n",
"### Autenticazione\n",
"\n",
"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:\n",
"\n",
"```python\n",
"from qiskit_ibm_catalog import QiskitServerless\n",
"\n",
"serverless = QiskitServerless(\n",
" channel=\"ibm_quantum_platform\",\n",
" instance=\"INSTANCE_CRN\",\n",
" # For `token`, use the 44-character API_KEY you created\n",
" # and saved from the IBM Quantum Platform Home dashboard\n",
" token=\"YOUR_API_KEY\"\n",
")\n",
"```\n",
"\n",
"Opzionalmente, si può usare `save_account()` per salvare le credenziali in un ambiente locale (vedere la guida [Impostare l'account IBM Cloud](/docs/guides/cloud-setup#cloud-save) ). Si noti che questo scrive le credenziali nello stesso file di [`QiskitRuntimeService.save_account()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#save_account):\n",
"\n",
"```python\n",
"QiskitServerless.save_account(token=\"YOUR_API_KEY\",\n",
" channel=\"ibm_quantum_platform\", instance=\"INSTANCE_CRN\")\n",
"```\n",
"\n",
"Se [l](/docs/guides/save-credentials) 'account è salvato, non è necessario fornire il token per l'autenticazione:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9276e2d4",
"metadata": {},
"outputs": [],
"source": [
"from qiskit_ibm_catalog import QiskitServerless\n",
"\n",
"serverless = QiskitServerless()"
]
},
{
"cell_type": "markdown",
"id": "e1f99d80",
"metadata": {
"vscode": {
"languageId": "plaintext"
}
},
"source": [
"\n",
"\n",
"### Carica il modello\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "3e0e8cc8",
"metadata": {
"vscode": {
"languageId": "plaintext"
}
},
"source": [
"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.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "77b2b9b6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"QiskitFunction(sqd_pcm_template)\n"
]
}
],
"source": [
"from qiskit_ibm_catalog import QiskitFunction\n",
"\n",
"template = QiskitFunction(\n",
" title=\"sqd_pcm_template\",\n",
" entrypoint=\"sqd_pcm_entrypoint.py\",\n",
" # all files in `working_dir` will be uploaded\n",
" working_dir=\"./source_files/\",\n",
" dependencies=[\n",
" \"ffsim==0.0.54\",\n",
" \"pyscf==2.9.0\",\n",
" \"qiskit_addon_sqd==0.10.0\",\n",
" ],\n",
")\n",
"print(template)"
]
},
{
"cell_type": "markdown",
"id": "72854f5a",
"metadata": {},
"source": [
"Una volta che l'istanza è pronta, caricarla su serverless:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "59e7fdb5",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"QiskitFunction(sqd_pcm_template)"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"serverless.upload(template)"
]
},
{
"cell_type": "markdown",
"id": "ac7d8764",
"metadata": {
"vscode": {
"languageId": "plaintext"
}
},
"source": [
"Per verificare se il programma è stato caricato con successo, utilizzare `serverless.list()`:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "03a91030",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[QiskitFunction(sqd_pcm_template),\n",
" QiskitFunction(hamiltonian_simulation_template)]"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"serverless.list()"
]
},
{
"cell_type": "markdown",
"id": "99408586",
"metadata": {},
"source": [
"\n",
"\n",
"## Caricare ed eseguire il modello in remoto\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "62b37d7a",
"metadata": {},
"source": [
"Il modello di funzione è stato caricato, quindi è possibile eseguirlo in remoto con Qiskit Serverless. Per prima cosa, caricare il modello per nome:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "854d12cf",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"QiskitFunction(sqd_pcm_template)\n"
]
}
],
"source": [
"template = serverless.load(\"sqd_pcm_template\")\n",
"print(template)"
]
},
{
"cell_type": "markdown",
"id": "fa2dc721",
"metadata": {
"vscode": {
"languageId": "plaintext"
}
},
"source": [
"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.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a1719ab1",
"metadata": {},
"outputs": [],
"source": [
"molecule = {\n",
" \"atom\": \"\"\"\n",
" O -0.04559 -0.75076 -0.00000;\n",
" C -0.04844 0.65398 -0.00000;\n",
" H 0.85330 -1.05128 -0.00000;\n",
" H -1.08779 0.98076 -0.00000;\n",
" H 0.44171 1.06337 0.88811;\n",
" H 0.44171 1.06337 -0.88811\n",
" \"\"\", # Must be specified\n",
" \"basis\": \"cc-pvdz\", # default is \"sto-3g\"\n",
" \"spin\": 0, # default is 0\n",
" \"charge\": 0, # default is 0\n",
" \"verbosity\": 0, # default is 0\n",
" \"number_of_active_orb\": 12, # Must be specified\n",
" \"number_of_active_alpha_elec\": 7, # Must be specified\n",
" \"number_of_active_beta_elec\": 7, # Must be specified\n",
" \"avas_selection\": [\n",
" \"%d O %s\" % (k, x) for k in [0] for x in [\"2s\", \"2px\", \"2py\", \"2pz\"]\n",
" ]\n",
" + [\"%d C %s\" % (k, x) for k in [1] for x in [\"2s\", \"2px\", \"2py\", \"2pz\"]]\n",
" + [\"%d H 1s\" % k for k in [2, 3, 4, 5]], # default is None\n",
"}\n",
"\n",
"solvent_options = {\n",
" # See https://manual.q-chem.com/5.4/topic_pcm-em.html for all methods\n",
" \"method\": \"IEF-PCM\", # other available methods are COSMO, C-PCM, SS(V)PE\n",
" \"eps\": 78.3553, # value for water\n",
"}\n",
"\n",
"lucj_options = {\n",
" \"initial_layout\": [\n",
" 0,\n",
" 14,\n",
" 18,\n",
" 19,\n",
" 20,\n",
" 33,\n",
" 39,\n",
" 40,\n",
" 41,\n",
" 53,\n",
" 60,\n",
" 61,\n",
" 2,\n",
" 3,\n",
" 4,\n",
" 15,\n",
" 22,\n",
" 23,\n",
" 24,\n",
" 34,\n",
" 43,\n",
" 44,\n",
" 45,\n",
" 54,\n",
" ],\n",
" \"dynamical_decoupling_choice\": True,\n",
" \"twirling_choice\": True,\n",
" \"number_of_shots\": 200000,\n",
" \"optimization_level\": 2,\n",
"}\n",
"\n",
"sqd_options = {\n",
" \"sqd_iterations\": 3,\n",
" \"number_of_batches\": 10,\n",
" \"samples_per_batch\": 1000,\n",
" \"max_davidson_cycles\": 200,\n",
"}\n",
"\n",
"backend_name = \"ibm_sherbrooke\""
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "01c0667c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"39f8fb70-79b2-43ca-b723-84e6b6135821\n"
]
}
],
"source": [
"job = template.run(\n",
" backend_name=backend_name,\n",
" molecule=molecule,\n",
" solvent_options=solvent_options,\n",
" lucj_options=lucj_options,\n",
" sqd_options=sqd_options,\n",
")\n",
"print(job.job_id)"
]
},
{
"cell_type": "markdown",
"id": "a9101a94",
"metadata": {},
"source": [
"Controllare lo stato dettagliato del lavoro:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "4385a34f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"time = 2.35, status = DONE\n"
]
}
],
"source": [
"import time\n",
"\n",
"t0 = time.time()\n",
"status = job.status()\n",
"if status == \"QUEUED\":\n",
" print(f\"time = {time.time()-t0:.2f}, status = QUEUED\")\n",
"while True:\n",
" status = job.status()\n",
" if status == \"QUEUED\":\n",
" continue\n",
" print(f\"time = {time.time()-t0:.2f}, status = {status}\")\n",
" if status == \"DONE\" or status == \"ERROR\":\n",
" break"
]
},
{
"cell_type": "markdown",
"id": "4adc5293",
"metadata": {},
"source": [
"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.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a5b1f190",
"metadata": {},
"outputs": [],
"source": [
"print(job.logs())"
]
},
{
"cell_type": "markdown",
"id": "ba179114",
"metadata": {},
"source": [
"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.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "3500adce",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'total_energy_hist': array([[-115.14768518, -115.1368396 , -114.19181692, -115.13745429,\n",
" -115.1445012 , -114.19673326, -115.1547003 , -114.20563866,\n",
" -115.13748344, -115.14764974],\n",
" [-115.15768392, -115.15850126, -115.15857275, -115.15770916,\n",
" -115.15801684, -115.15822125, -115.15833521, -115.15844051,\n",
" -115.15735538, -115.15862354],\n",
" [-115.15795148, -115.15847925, -115.15856677, -115.15811156,\n",
" -115.15815602, -115.15785171, -115.1583672 , -115.1585533 ,\n",
" -115.15833528, -115.15808791]]),\n",
" 'spin_squared_value_hist': array([[5.37327508e-03, 1.32981759e-02, 1.36214922e-02, 8.84413615e-03,\n",
" 7.26723578e-03, 1.94875195e-02, 3.03153152e-03, 6.07543106e-03,\n",
" 1.04951849e-02, 5.36529204e-03],\n",
" [6.39397528e-04, 1.36814350e-04, 9.09054260e-05, 5.99361358e-04,\n",
" 3.64261739e-04, 2.54905866e-04, 2.32540370e-04, 1.53181990e-04,\n",
" 7.23519739e-04, 6.80737671e-05],\n",
" [4.53776416e-04, 1.63043449e-04, 1.05317263e-04, 3.82912836e-04,\n",
" 3.41047803e-04, 5.18620393e-04, 2.06819142e-04, 1.17086537e-04,\n",
" 2.32357159e-04, 4.26071537e-04]]),\n",
" 'solvation_free_energy_hist': array([[-0.00725018, -0.00743955, -0.01132905, -0.0073377 , -0.00722221,\n",
" -0.01136705, -0.00719279, -0.01072829, -0.00733404, -0.00725961],\n",
" [-0.00719252, -0.00718315, -0.00718074, -0.00719325, -0.00717703,\n",
" -0.00718391, -0.00718354, -0.00717928, -0.00719887, -0.0071801 ],\n",
" [-0.00719351, -0.00718255, -0.00718198, -0.00718429, -0.00718349,\n",
" -0.00718329, -0.0071882 , -0.00718363, -0.00718549, -0.00718814]]),\n",
" 'occupancy_hist': [[array([0.99712298, 0.99278936, 0.99083163, 0.97328469, 0.98959809,\n",
" 0.98922134, 0.720333 , 0.25683194, 0.01939338, 0.02840332,\n",
" 0.00946988, 0.0327204 ]),\n",
" array([0.99712298, 0.99278936, 0.99083163, 0.97328469, 0.98959809,\n",
" 0.98922134, 0.720333 , 0.25683194, 0.01939338, 0.02840332,\n",
" 0.00946988, 0.0327204 ])],\n",
" [array([0.9959042 , 0.9922607 , 0.99018862, 0.99265843, 0.98927447,\n",
" 0.9900833 , 0.99403876, 0.00989025, 0.01120814, 0.01137717,\n",
" 0.01152871, 0.01158725]),\n",
" array([0.9959042 , 0.9922607 , 0.99018862, 0.99265843, 0.98927447,\n",
" 0.9900833 , 0.99403876, 0.00989025, 0.01120814, 0.01137717,\n",
" 0.01152871, 0.01158725])],\n",
" [array([0.99590079, 0.99222193, 0.99016753, 0.99265045, 0.98927264,\n",
" 0.99007179, 0.99407207, 0.00986684, 0.01125181, 0.01141439,\n",
" 0.01150733, 0.01160243]),\n",
" array([0.99590079, 0.99222193, 0.99016753, 0.99265045, 0.98927264,\n",
" 0.99007179, 0.99407207, 0.00986684, 0.01125181, 0.01141439,\n",
" 0.01150733, 0.01160243])]],\n",
" 'lowest_energy_batch': 2,\n",
" 'lowest_energy_value': -115.1585667736213,\n",
" 'solvation_free_energy': -0.007181981952470838,\n",
" 'sci_solver_total_duration': 493.997501373291,\n",
" 'metadata': {'resources_usage': {'RUNNING: MAPPING': {'CPU_TIME': 6.080063343048096},\n",
" 'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 1.999896764755249},\n",
" 'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 6.2850868701934814},\n",
" 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 21.639373540878296},\n",
" 'RUNNING: POST_PROCESSING': {'CPU_TIME': 495.40831995010376}},\n",
" 'num_iterations_executed': 3}}"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"result = job.result()\n",
"\n",
"result"
]
},
{
"cell_type": "markdown",
"id": "94a2c921",
"metadata": {},
"source": [
"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).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "49d0b26d",
"metadata": {
"vscode": {
"languageId": "plaintext"
}
},
"source": [
"Al termine del lavoro, sarà disponibile l'intero output di registrazione.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "ddcba564",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2025-06-27 08:42:41,358\tINFO job_manager.py:531 -- Runtime env is setting up.\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:45,015: Starting runtime service\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:45,621: Backend: ibm_sherbrooke\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:46,809: Initializing molecule object\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:51,599: Performing CCSD\n",
"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\n",
"Overwritten attributes get_ovlp get_hcore of \n",
"/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\n",
" warnings.warn(msg)\n",
"/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\n",
" warnings.warn(msg)\n",
"converged SCF energy = -115.049680672847\n",
"E(CCSD) = -115.1519910037652 E_corr = -0.1023103309180226\n",
"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)]\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:51,694: Opposite spin orbital connections: [(0, 0), (4, 4), (8, 8)]\n",
"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\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:53,736: Two-qubit gate depth: 94\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:53,737: Submitting sampler job\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:54,273: Job ID: d1f5j3lqbivc73ebqpj0\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:42:54,313: Job Status: QUEUED\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,813: Starting configuration recovery iteration 0\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,841: Batch 0 subspace dimension: 531441\n",
"2025-06-27 08:43:24,844\tINFO worker.py:1588 -- Using address 172.17.16.124:6379 set in the environment variable RAY_ADDRESS\n",
"2025-06-27 08:43:24,847\tINFO worker.py:1723 -- Connecting to existing Ray cluster at address: 172.17.16.124:6379...\n",
"2025-06-27 08:43:24,876\tINFO worker.py:1908 -- Connected to Ray cluster. View the dashboard at \u001b[1m\u001b[32mhttp://172.17.16.124:8265 \u001b[39m\u001b[22m\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,945: Batch 1 subspace dimension: 519841\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,950: Batch 2 subspace dimension: 543169\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,955: Batch 3 subspace dimension: 532900\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,960: Batch 4 subspace dimension: 534361\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,964: Batch 5 subspace dimension: 531441\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,969: Batch 6 subspace dimension: 540225\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,974: Batch 7 subspace dimension: 524176\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,979: Batch 8 subspace dimension: 537289\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:43:24,983: Batch 9 subspace dimension: 540225\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:09,006: Lowest energy batch: 6\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:09,007: Lowest energy value: -115.15470029849135\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:09,007: Corresponding g_solv value: -0.0071927910374866375\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:09,007: -----------------------------------\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:09,007: Starting configuration recovery iteration 1\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,564: Batch 0 subspace dimension: 413449\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,572: Batch 1 subspace dimension: 399424\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,578: Batch 2 subspace dimension: 438244\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,583: Batch 3 subspace dimension: 422500\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,589: Batch 4 subspace dimension: 409600\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,596: Batch 5 subspace dimension: 404496\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,601: Batch 6 subspace dimension: 410881\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,605: Batch 7 subspace dimension: 442225\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,611: Batch 8 subspace dimension: 409600\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:48:40,618: Batch 9 subspace dimension: 405769\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:49:54,917: Lowest energy batch: 9\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:49:54,917: Lowest energy value: -115.15862353596414\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:49:54,917: Corresponding g_solv value: -0.0071800982859467006\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:49:54,918: -----------------------------------\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:49:54,918: Starting configuration recovery iteration 2\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,501: Batch 0 subspace dimension: 399424\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,508: Batch 1 subspace dimension: 412164\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,514: Batch 2 subspace dimension: 432964\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,519: Batch 3 subspace dimension: 400689\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,524: Batch 4 subspace dimension: 432964\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,529: Batch 5 subspace dimension: 418609\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,533: Batch 6 subspace dimension: 418609\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,538: Batch 7 subspace dimension: 425104\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,543: Batch 8 subspace dimension: 404496\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:50:25,548: Batch 9 subspace dimension: 429025\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:51:37,900: Lowest energy batch: 2\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:51:37,900: Lowest energy value: -115.1585667736213\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:51:37,901: Corresponding g_solv value: -0.007181981952470838\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:51:37,901: -----------------------------------\n",
"sqd_pcm_entrypoint.run_function:INFO:2025-06-27 08:51:37,901: SCI_solver totally takes: 493.997501373291 seconds\n",
"\n"
]
}
],
"source": [
"print(job.logs())"
]
},
{
"cell_type": "markdown",
"id": "bf0750f3",
"metadata": {},
"source": [
"\n",
"\n",
"## Cita questo progetto\n",
"\n",
"Se utilizzate il modello SQD IEF-PCM nella vostra ricerca, vi preghiamo di consultare [l](https://github.com/qiskit-community/qiskit-function-templates/tree/main/chemistry/sqd_pcm#citing-this-project) 'archivio per informazioni dettagliate sulla citazione.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "d7cc1cb2",
"metadata": {},
"source": [
"\n",
"\n",
"## Passi successivi\n",
"\n",
"\n",
" * Segui il tutorial “[Calcoli del solvente implicito utilizzando l’ Qiskit Serverless](/docs/tutorials/implicit-solvent-calculations) ” per un esempio pratico di questo stesso flusso di lavoro\n",
" * Consulta la guida sulla creazione di un modello di funzione per [la simulazione hamiltoniana](/docs/guides/function-template-hamiltonian-simulation)\n",
" * Consultate i file sorgenti di questo modello su [GitHub](https://github.com/qiskit-community/qiskit-function-templates/tree/main/chemistry/sqd_pcm)\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "aabba015",
"metadata": {},
"source": [
"\n",
"\n",
"#### Riferimenti\n",
"\n",
"\\[1] Danil Kaliakin, Akhil Shajan, Fangchun Liang e Kenneth M. Merz Jr. [Implicit Solvent Sample-Based Quantum Diagonalization](https://pubs.acs.org/doi/10.1021/acs.jpcb.5c01030), The Journal of Physical Chemistry B, 2025, DOI: 10.1021/acs.jpcb.5c01030\n",
"\n",
"\\[2] Javier Robledo-Moreno, et al, [Chemistry Beyond Exact Solutions on a Quantum-Centric Supercomputer](https://arxiv.org/abs/2405.05068), arXiv:2405.05068 \\[quant-ph].\n",
"\n",
"\\[3] Jeffery Yu, et al, [Algoritmo quantistico per la diagonalizzazione di Krylov basata su campioni](https://arxiv.org/abs/2501.09702), arXiv:2501.09702 \\[quant-ph].\n",
"\n",
"\\[4] Keita Kanno, et al, [Quantum-Selected Configuration Interaction: classical diagonalization of Hamiltonians in subspaces selected by quantum computers](https://arxiv.org/abs/2302.11320), arXiv:2302.11320 \\[quant-ph].\n",
"\n",
"\\[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](https://arxiv.org/abs/2412.07218), arXiv:2412.07218 \\[quant-ph].\n",
"\n",
"\\[6] Mathias Mikkelsen, Yuya O. Nakagawa, [Quantum-selected configuration interaction with time-evolved state](https://arxiv.org/abs/2412.13839), arXiv:2412.13839 \\[quant-ph].\n",
"\n",
"\\[7] Herbert, John M. [Metodi di continuum dielettrico per la chimica quantistica. WIREs Computational Molecular Science](https://wires.onlinelibrary.wiley.com/doi/10.1002/wcms.1519), 2021, 11, 1759-0876.\n",
"\n",
"\\[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](https://github.com/Qiskit/qiskit-addon-sqd)\n",
"\n",
"\\[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](https://github.com/pyscf/pyscf)\n",
"\n",
"\\[10] Kevin J. Sung; et al., FFSIM: simulazioni più veloci di circuiti quantistici fermionici, 2024. [https://github.com/qiskit-community/ffsim](https://github.com/qiskit-community/ffsim)\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3"
}
},
"nbformat": 4,
"nbformat_minor": 5
}