Applications de l'informatique quantique - Chimie

Mars

2022

La compréhension des propriétés des produits chimiques par le biais de simulations numériques a été un élément clé du développement de la chimie. Mais la modélisation des interactions atomiques sur des ordinateurs classiques dépasse rapidement la capacité de calcul des plus grands superordinateurs.

Les ordinateurs quantiques peuvent aider. Au lieu d'effectuer des approximations "grossières" sur des ordinateurs classiques, les scientifiques peuvent réaliser des simulations beaucoup plus précises sur des machines quantiques.

Une application courante de la chimie quantique consiste à rechercher l'énergie de l'état fondamental d'une molécule en trouvant la valeur propre minimale d'une matrice la caractérisant. Bien que cela puisse être réalisé à l'avenir en utilisant l'estimation de la phase quantique, il est possible de le faire aujourd'hui en utilisant des circuits beaucoup moins profonds avec l'algorithme Variational Quantum Eigensolver (VQE).

Les ordinateurs quantiques actuels ayant une fidélité limitée, il est courant de concevoir des algorithmes hybrides quantiques-classiques qui tirent parti des atouts de chaque paradigme informatique. Par exemple, l'ordinateur classique pourrait effectuer une optimisation non convexe et l'ordinateur quantique pourrait calculer efficacement la fonction cible. Cette approche hybride peut s'avérer intéressante pour résoudre des problèmes que même la théorie de la fonctionnelle de la densité (DFT) ou les approximations Hartree-Fock ne peuvent résoudre.

Voici ce que cela donne avec Classiq :

‍

Utilisons Classiq pour résoudre un problème d'état fondamental pour la molécule H2, en commençant par notre SDK Python. Pour ce faire, nous générons un hamiltonien, nous créons un circuit quantique variationnel pour calculer l'état fondamental de l'hamiltonien, et nous exécutons ce circuit dans un algorithme hybride quantique-classique VQE.

Ici, nous définissons le problème comme une molécule H2, en utilisant la bibliothèque d'atomes Classiq, en spécifiant leur emplacement, leur charge et leur spin. Ce bloc de code se termine par la génération du hamiltonien.


from classiq import ModelDesigner, Executor
from classiq.builtin_functions import UCC, HartreeFock

from classiq.interface.chemistry.molecule import Molecule
from classiq.interface.chemistry.ground_state_problem import GroundStateProblem
from classiq.interface.backend.backend_preferences import IBMBackendPreferences, BackendPreferences
from classiq.interface.executor.execution_preferences import ExecutionPreferences, OptimizerPreferences
from classiq.interface.executor.hamiltonian_minimization_problem import HamiltonianMinimizationProblem
from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
from classiq.interface.executor.quantum_program import QuantumProgram


molecule = Molécule(
    atomes=[
        ("H", (0.0, 0.0, 0.0)),
        ("H", (0.0, 0.0, 3.0)),
        ],
)
gs_problem = GroundStateProblem(
    molecule=molecule,
    mapping="jordan_wigner",
)

operator = gs_problem.generate_hamiltonian()

Nous créons maintenant un ansatz, ou une supposition paramétrée initiale pour notre algorithme VQE, à l'aide de l'hamiltonien généré. Cette section du code crée un circuit quantique efficace sur le plan matériel pour représenter l'ansatz. La plateforme Classiq synthétise des circuits quantiques dans de nombreux langages, avec par défaut Open QASM 2.0.


model_designer = ModelDesigner()

hf_params = HartreeFock(gs_problem=gs_problem)
output_dict = model_designer.HartreeFock(params=hf_params)
hf_output = output_dict["OUT"]

ucc_params = UCC(gs_problem=gs_problem, excitations=[1,2], max_depth=100)

model_designer.UCC(params=ucc_params, in_wires={"IN": hf_output})
circuit = model_designer.synthesize()
circuit_qasm = circuit.qasm

Enfin, nous exécutons l'algorithme VQE, en itérant 30 fois, en utilisant le code QASM de la section précédente comme entrée et en spécifiant que l'algorithme est exécuté par le simulateur aer d'IBMQ.


optimizer_preferences = OptimizerPreferences(
    max_iteration=30
)
backend_preferences = IBMBackendPreferences(
    backend_service_provider="IBMQ", backend_name="aer_simulator"
)
num_shots = 1000
execution_preferences = ExecutionPreferences(
    num_shots=num_shots,
    backend_preferences=backend_preferences,
    optimizer_preferences=optimizer_preferences
)
hamiltonian_problem = HamiltonianMinimizationProblem(
    ansatz=QuantumProgram(code=circuit_qasm, syntax=QuantumInstructionSet.QASM),
    hamiltonien=opérateur
)
result = Executor(
    préférences=préférences_exécution
).execute_hamiltonian_minimization(hamiltonian_problem)

print("L'énergie de l'état fondamental de H2 est", result.energy)
print("Les paramètres optimaux de l'ansatz sont", result.optimal_parameters)
result.show_convergence_graph()

‍

L'énergie de l'état fondamental et les paramètres optimaux sont affichés. Ces paramètres correspondent aux angles de l'ansatz, et notre graphique de convergence montre comment l'algorithme a trouvé la bonne solution.

Nous pouvons également procéder de la même manière avec notre modèle textuel, en exécutant simplement le code suivant.


{
    "ground_state_problem": {
        "molecule": {
            "atoms": [
                ["H", [0, 0, 0]],
                ["H", [0, 0, 3]]
            ]
        },
        "basis": "sto3g",
        "mapping": "jordan_wigner"
    },
    "quantum_circuit_constraints": {
        "logic_flow": [
            {
               "function": "HartreeFock",
               "function_params": {"gs_problem": "ground_state_problem"},
               "outputs": {"OUT": "hf_out"},
               "name": "HartreeFock"
            },
            {
                "function": "UCC",
                "function_params": {
                    "gs_problem": "ground_state_problem",
                    "excitations": [1,2],
                    "max_depth": 100
                },
                "inputs": {"IN": "hf_out"},
                "name": "UCC"
            }
        ]
    },
    "execution_preferences": {
        "optimizer_preferences": {
            "cost_type": "AVERAGE",
            "max_iteration": 30
        },
        "backend_preferences": {
            "backend_service_provider": "IBMQ",
            "backend_name": "aer_simulator"
        },
        "num_shots": 1000
    }
}

‍

Intéressé à voir ce que la plateforme Classiq peut apporter à votre organisation ? Contactez-nous pour planifier une démonstration

Voici ce que cela donne avec Classiq :

‍


from classiq import ModelDesigner, Executor
from classiq.builtin_functions import UCC, HartreeFock

from classiq.interface.chemistry.molecule import Molecule
from classiq.interface.chemistry.ground_state_problem import GroundStateProblem
from classiq.interface.backend.backend_preferences import IBMBackendPreferences, BackendPreferences
from classiq.interface.executor.execution_preferences import ExecutionPreferences, OptimizerPreferences
from classiq.interface.executor.hamiltonian_minimization_problem import HamiltonianMinimizationProblem
from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
from classiq.interface.executor.quantum_program import QuantumProgram


molecule = Molécule(
    atomes=[
        ("H", (0.0, 0.0, 0.0)),
        ("H", (0.0, 0.0, 3.0)),
        ],
)
gs_problem = GroundStateProblem(
    molecule=molecule,
    mapping="jordan_wigner",
)

operator = gs_problem.generate_hamiltonian()


model_designer = ModelDesigner()

hf_params = HartreeFock(gs_problem=gs_problem)
output_dict = model_designer.HartreeFock(params=hf_params)
hf_output = output_dict["OUT"]

ucc_params = UCC(gs_problem=gs_problem, excitations=[1,2], max_depth=100)

model_designer.UCC(params=ucc_params, in_wires={"IN": hf_output})
circuit = model_designer.synthesize()
circuit_qasm = circuit.qasm


optimizer_preferences = OptimizerPreferences(
    max_iteration=30
)
backend_preferences = IBMBackendPreferences(
    backend_service_provider="IBMQ", backend_name="aer_simulator"
)
num_shots = 1000
execution_preferences = ExecutionPreferences(
    num_shots=num_shots,
    backend_preferences=backend_preferences,
    optimizer_preferences=optimizer_preferences
)
hamiltonian_problem = HamiltonianMinimizationProblem(
    ansatz=QuantumProgram(code=circuit_qasm, syntax=QuantumInstructionSet.QASM),
    hamiltonien=opérateur
)
result = Executor(
    préférences=préférences_exécution
).execute_hamiltonian_minimization(hamiltonian_problem)

print("L'énergie de l'état fondamental de H2 est", result.energy)
print("Les paramètres optimaux de l'ansatz sont", result.optimal_parameters)
result.show_convergence_graph()

‍

Nous pouvons également procéder de la même manière avec notre modèle textuel, en exécutant simplement le code suivant.


{
    "ground_state_problem": {
        "molecule": {
            "atoms": [
                ["H", [0, 0, 0]],
                ["H", [0, 0, 3]]
            ]
        },
        "basis": "sto3g",
        "mapping": "jordan_wigner"
    },
    "quantum_circuit_constraints": {
        "logic_flow": [
            {
               "function": "HartreeFock",
               "function_params": {"gs_problem": "ground_state_problem"},
               "outputs": {"OUT": "hf_out"},
               "name": "HartreeFock"
            },
            {
                "function": "UCC",
                "function_params": {
                    "gs_problem": "ground_state_problem",
                    "excitations": [1,2],
                    "max_depth": 100
                },
                "inputs": {"IN": "hf_out"},
                "name": "UCC"
            }
        ]
    },
    "execution_preferences": {
        "optimizer_preferences": {
            "cost_type": "AVERAGE",
            "max_iteration": 30
        },
        "backend_preferences": {
            "backend_service_provider": "IBMQ",
            "backend_name": "aer_simulator"
        },
        "num_shots": 1000
    }
}

‍

Intéressé à voir ce que la plateforme Classiq peut apporter à votre organisation ? Contactez-nous pour planifier une démonstration

A propos de "The Qubit Guy's Podcast" (Le podcast du gars de Qubit)

Animé par The Qubit Guy (Yuval Boger, notre directeur marketing), le podcast accueille des leaders d'opinion de l'informatique quantique pour discuter de questions commerciales et techniques qui ont un impact sur l'écosystème de l'informatique quantique. Nos invités fournissent des informations intéressantes sur les logiciels et algorithmes d'ordinateurs quantiques, le matériel informatique quantique, les applications clés de l'informatique quantique, les études de marché de l'industrie quantique et bien plus encore.

Si vous souhaitez proposer un invité pour le podcast, veuillez nous contacter.