Créer et exécuter un modèle de fonction Qiskit pour la simulation de la structure électronique à l'aide d'un modèle de solvant implicite

Ce modèle, développé en collaboration avec la Cleveland Clinic, consiste en un flux de travail permettant de calculer l'énergie de l'état fondamental et l'énergie libre de solvatation d'une molécule dans un solvant implicite [1]. Ces simulations sont basées sur la méthode de diagonalisation quantique basée sur l'échantillon (SQD) [2-6] et sur le modèle de continuum polarisable du formalisme de l'équation intégrale (IEF-PCM) du solvant [7].

Pour un guide détaillé, étape par étape, de ce même processus de travail, accompagné d'un exemple concret, consultez le tutoriel « Calculs avec solvant implicite à l'aide d' Qiskit Serverless ».

Ce guide utilise le modèle avec une molécule de méthanol comme soluté, dont la structure électronique est simulée explicitement, et de l'eau comme solvant, approximé comme un milieu diélectrique continu. Pour tenir compte des effets de corrélation électronique dans le méthanol, tout en maintenant l'équilibre entre le coût de calcul et la précision, nous n'incluons que les orbitales $\sigma$ , $\sigma^{*}$ , et les paires solitaires dans l'espace actif simulé avec SQD IEF-PCM. Cette sélection d'orbitales est effectuée avec la méthode de l'espace actif de valence atomique (AVAS) en utilisant les composantes orbitales atomiques [C2s,2p], O2s[,2p] et [H1s], ce qui donne un espace actif de 14 électrons et 12 orbitales ( 14e,12o ). Les orbitales de référence sont calculées avec la méthode Hartree Fock à coquille fermée en utilisant le jeu de base cc-pvdz.

Présentation du flux de travail

Ce guide interactif montre comment télécharger ce modèle de fonction sur Qiskit Serverless et exécuter une charge de travail d'exemple. Le modèle est structuré comme un modèle Qiskit en quatre étapes :

1. Recueillir les informations et cartographier le problème

Cette étape prend en entrée la géométrie de la molécule, l'espace actif sélectionné, le modèle de solvatation, les options LUCJ et les options SQD. Il produit ensuite le fichier PySCF Checkpoint, qui contient les données Hartree-Fock (HF) IEF-PCM. Ces données seront utilisées dans la partie SQD du flux de travail. Pour la partie LUCJ du flux de travail, la section d'entrée génère également les données HF en phase gazeuse, qui sont stockées en interne au format PySCF FCIDUMP.

Les informations provenant de la simulation HF de la phase gazeuse et la définition de l'espace actif sont prises comme données d'entrée. Il est important de noter qu'il utilise également les informations définies par l'utilisateur dans la section d'entrée concernant la suppression des erreurs, le nombre de tirs, le niveau d'optimisation du transpondeur de circuit et la disposition des qubits.

Il génère des intégrales à un électron et à deux électrons dans l'espace actif défini. Les intégrales sont ensuite utilisées pour effectuer des calculs CCSD classiques, qui renvoient à t2 des amplitudes que nous utilisons pour paramétrer le circuit LUCJ.

2. Optimiser le circuit

Le circuit LUCJ est ensuite transposé dans un circuit ISA pour le matériel cible. Un échantillonneur primitif est alors instancié avec un ensemble par défaut d'options d'atténuation des erreurs pour gérer l'exécution.

3. Exécutez le circuit

Les calculs de LUCJ renvoient les chaînes de bits pour chaque mesure, ces chaînes de bits correspondant aux configurations électroniques du système étudié. Les chaînes de bits sont ensuite utilisées comme entrée pour le post-traitement.

4. Post-traitement à l'aide de SQD

Cette dernière étape prend comme entrée le fichier Checkpoint PySCF contenant les informations IEF-PCM HF, les chaînes de bits représentant les configurations électroniques prédites par LUCJ, et les options SQD définies par l'utilisateur et sélectionnées dans la section d'entrée. En sortie, il produit l'énergie totale SQD IEF-PCM du lot le moins énergétique et l'énergie libre de solvatation correspondante.

Options

Pour ce modèle, vous devez spécifier les options de génération du circuit LUCJ et les paramètres d'exécution SQD.

Options LUCJ

Lorsque le circuit quantique LUCJ est exécuté, un ensemble d'échantillons représentant les états de base de calcul de la distribution de probabilité du système moléculaire est produit. Pour équilibrer la profondeur du circuit LUCJ et son expressivité, les qubits correspondant aux orbitales de spin opposé ont les portes à deux qubits appliquées entre eux lorsque ces qubits sont voisins par l'intermédiaire d'un seul qubit d'ancilla. Pour mettre en œuvre cette approche sur le matériel IBM avec une topologie heavy-hex, les qubits qui représentent les orbitales de spin avec le même spin sont connectés par une topologie de ligne où chaque ligne prend une forme de zig-zag en raison de la connectivité heavy-hex du matériel cible, tandis que les qubits qui représentent les orbitales de spin avec le spin opposé n'ont une connexion que tous les quatre qubits.

L'utilisateur doit fournir le tableau initial_layout correspondant aux qubits qui satisfont à ce modèle en zig-zag dans la section lucj_options de la fonction SQD IEF-PCM. Dans le cas des simulations SQD IEF-PCM ( 14e,12o )/cc-pvdz du méthanol, nous avons choisi la disposition initiale des qubits correspondant à la diagonale principale de la QPU Eagle R3. Ici, les 12 premiers éléments du tableau initial_layout [0, 14, 18, 19, 20, 33, 39, 40, 41, 53, 60, 61, ...] correspondent aux orbitales de spin alpha. Les 12 derniers éléments [... 2, 3, 4, 15, 22, 23, 24, 34, 43, 44, 45, 54] correspondent à des orbitales de spin bêta.
Il est important que l'utilisateur détermine le number_of_shots, qui correspond au nombre de mesures dans le circuit LUCJ. Le nombre de tirs doit être suffisamment important car la première étape de la procédure S-CORE s'appuie sur les échantillons du secteur des particules de droite pour obtenir l'approximation initiale de la distribution du nombre d'occupation de l'état fondamental.
Le nombre de plans dépend fortement du système et du matériel, mais les études SQD non covalentes, basées sur les fragments et les solvants implicites suggèrent qu'il est possible d'atteindre la précision chimique en suivant ces lignes directrices :
- 20 000 - 200 000 tirs pour les systèmes comportant moins de 16 orbitales moléculaires (32 orbitales de spin)
- 200 000 tirs pour les systèmes comportant 16 à 18 orbitales moléculaires
- 200 000 - 2 000 000 tirs pour les systèmes comportant plus de 18 orbitales moléculaires
Le nombre de calculs requis dépend du nombre d'orbitales de spin dans le système étudié et de la taille de l'espace de Hilbert correspondant à l'espace actif sélectionné au sein de ce système. En général, les cas impliquant des espaces de Hilbert plus petits nécessitent moins d'itérations. Parmi les autres options disponibles de LUCJ, on trouve le niveau d'optimisation du transpileur de circuits et les options de suppression des erreurs. Notez que ces options ont également une incidence sur le nombre de tirs requis et sur la précision obtenue.

Options SQD

Les options importantes dans les simulations SQD sont les suivantes : sqd_iterations, number_of_batches, et samples_per_batch. En général, le nombre inférieur d'échantillons par lot peut être compensé par un plus grand nombre de lots (number_of_batches) et un plus grand nombre d'itérations de S-CORE (sqd_iterations). Avec plus de lots, nous pouvons échantillonner plus de variations des sous-espaces configurationnels. Étant donné que le lot de plus faible énergie est considéré comme la solution pour l'énergie de l'état fondamental du système, un plus grand nombre de lots peut améliorer les résultats grâce à de meilleures statistiques. Des itérations supplémentaires de S-CORE permettent de récupérer davantage de configurations à partir de la distribution LUCJ originale si le nombre d'échantillons dans le secteur de particules correct est faible. Cela peut permettre de réduire le nombre d'échantillons par lot.

Une autre stratégie consiste à utiliser davantage d'échantillons par lot, ce qui garantit que la plupart des échantillons LUCJ initiaux dans l'espace de particules droit sont utilisés au cours de la procédure S-CORE et que les sous-espaces individuels englobent une variété suffisante de configurations d'électrons. Cela permet de réduire le nombre d'étapes S-CORE nécessaires, où seules deux ou trois itérations de SQD sont nécessaires si le nombre d'échantillons par lot est suffisamment important. Cependant, un plus grand nombre d'échantillons par lot entraîne un coût de calcul plus élevé pour chaque étape de diagonalisation. Par conséquent, l'équilibre entre la précision et le coût de calcul dans les simulations SQD peut être atteint en choisissant sqd_iterations, number_of_batches, et samples_per_batch de manière optimale.
L' étude SQD IEF-PCM montre que lorsque trois itérations de S-CORE sont utilisées, la précision chimique peut être atteinte en suivant ces lignes directrices :
- 600 échantillons par lot dans le méthanol SQD IEF-PCM ( 14e,12o ) simulations
- 1500 échantillons par lot en méthylamine SQD IEF-PCM ( 14e,13o ) simulations
- 6000 échantillons par lot dans les simulations SQD IEF-PCM ( 8e,23o ) de l'eau
- 16 000 échantillons par lot dans les simulations SQD IEF-PCM ( 20e,18o ) pour l'éthanol
Tout comme le nombre requis de tirs dans LUCJ, le nombre requis d'échantillons par lot utilisé dans la procédure S-CORE dépend fortement du système et du matériel. Les exemples ci-dessus peuvent être utilisés pour estimer le point initial du nombre d'échantillons requis par lot. Le tutoriel sur l'évaluation systématique du nombre d'échantillons requis par lot est disponible ici.

Déployer et exécuter la fonction SQD IEF-PCM du modèle

Authentification

Utilisez qiskit-ibm-catalog pour vous authentifier auprès de QiskitServerless avec votre clé API (token), qui se trouve sur le tableau de bord de IBM Quantum Platform. Cela permet d'instancier le client sans serveur pour télécharger ou exécuter la fonction sélectionnée :

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

En option, utilisez save_account() pour sauvegarder vos informations d'identification dans un environnement local (voir le guide Configurer votre compte IBM Cloud ). Notez que cela écrit vos informations d'identification dans le même fichier que QiskitRuntimeService.save_account():

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

Si le compte est enregistré, il n'est pas nécessaire de fournir le jeton pour s'authentifier :

from qiskit_ibm_catalog import QiskitServerless

serverless = QiskitServerless()

Télécharger le modèle

Pour télécharger une fonction Qiskit personnalisée, vous devez d'abord instancier un objet QiskitFunction qui définit le code source de la fonction. Le titre vous permettra d'identifier la fonction une fois qu'elle sera dans le télégraphe. Le principal point d'entrée est le fichier qui contient if __name__ == "__main__". Si votre flux de travail nécessite des fichiers sources supplémentaires, vous pouvez définir un répertoire de travail qui sera téléchargé avec le point d'entrée.

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)

Une fois l'instance prête, téléchargez-la sur serverless :

serverless.upload(template)

Output:

QiskitFunction(sqd_pcm_template)

Pour vérifier si le programme a été téléchargé avec succès, utilisez serverless.list():

serverless.list()

Output:

[QiskitFunction(sqd_pcm_template),
 QiskitFunction(hamiltonian_simulation_template)]

Charger et exécuter le modèle à distance

Le modèle de fonction a été téléchargé, vous pouvez donc l'exécuter à distance avec Qiskit Serverless. Tout d'abord, chargez le modèle par son nom :

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

Output:

QiskitFunction(sqd_pcm_template)

Ensuite, exécutez le modèle avec les entrées au niveau du domaine pour SQD-IEF PCM. Cet exemple spécifie une charge de travail à base de méthanol.

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

Vérifier l'état détaillé du travail :

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

Pendant l'exécution du travail, vous pouvez récupérer les journaux créés à partir des sorties de logger.info . Ils peuvent fournir des informations exploitables sur la progression du flux de travail SQD IEF-PCM. Par exemple, les mêmes connexions orbitales de spin, ou la profondeur de deux qubits du circuit ISA final destiné à être exécuté sur le matériel.

print(job.logs())

L'appel du résultat du travail bloque le reste du programme jusqu'à ce qu'un résultat soit disponible. Une fois le travail effectué, vous pouvez récupérer les résultats. Il s'agit notamment de l'énergie libre de solvatation, ainsi que d'informations sur le lot de l'énergie la plus basse, la valeur de l'énergie la plus basse et d'autres informations utiles telles que la durée totale du solveur.

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

Notez que les métadonnées des résultats incluent un résumé de l'utilisation des ressources qui vous permet de mieux estimer le temps QPU et CPU requis pour chaque charge de travail (cet exemple a été exécuté sur un appareil factice, les temps d'utilisation réels des ressources peuvent donc différer).

Une fois le travail terminé, l'ensemble de la sortie de la journalisation sera disponible.

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

Référencer ce projet

Si vous utilisez le modèle SQD IEF-PCM dans le cadre de vos travaux de recherche, veuillez consulter le référentiel pour obtenir des informations détaillées sur la citation.

Etapes suivantes

Recommandations

Suivez le tutoriel « Calculs de solvant implicite à l'aide d' Qiskit Serverless » pour découvrir un exemple concret de ce même processus
Consultez le guide sur la création d'un modèle de fonction pour la simulation hamiltonienne
Consultez les fichiers sources de ce modèle sur GitHub

Références

[1] Danil Kaliakin, Akhil Shajan, Fangchun Liang, and 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, Quantum-Centric Algorithm for Sample-Based Krylov Diagonalization, 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, Hamiltonian simulation-based quantum-selected configuration interaction for large-scale electronic structure calculations with a quantum computer, 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. Méthodes de continuum diélectrique pour la chimie quantique. 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. Qiskit addon : sample-based quantum diagonalization, 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 -basé sur des simulations du cadre de la chimie, 2025; https://github.com/pyscf/pyscf

[10] Kevin J. Sung; et al, FFSIM : simulations plus rapides de circuits quantiques fermioniques, 2024. https://github.com/qiskit-community/ffsim

Cette page a-t-elle été utile ?

Signaler un bogue, une coquille ou proposer du contenu sur GitHub.