Anwendungen der Quanteninformatik - Chemie

März

2022

Das Verständnis der Eigenschaften chemischer Stoffe durch numerische Simulationen hat die chemische Entwicklung entscheidend vorangebracht. Doch die Modellierung atomarer Wechselwirkungen auf klassischen Computern übersteigt schnell die Rechenkapazität selbst der größten Supercomputer.

Quantencomputer können helfen. Anstatt "grobkörnige" Annäherungen auf klassischen Computern durchzuführen, können Wissenschaftler auf Quantencomputern viel präzisere Simulationen durchführen.

Eine häufige Anwendung in der Quantenchemie ist die Suche nach der Grundzustandsenergie eines Moleküls durch Ermittlung des minimalen Eigenwerts einer Matrix, die es charakterisiert. Dies könnte in Zukunft mit Hilfe der Quantenphasenschätzung geschehen, kann aber schon heute mit dem Variational Quantum Eigensolver (VQE)-Algorithmus mit viel geringeren Schaltungen durchgeführt werden.

Da die heutigen Quantencomputer nur über eine begrenzte Genauigkeit verfügen, ist es üblich, hybride quantenklassische Algorithmen zu entwickeln, die die Stärken der einzelnen Rechenparadigmen nutzen. Beispielsweise könnte der klassische Computer eine nicht-konvexe Optimierung durchführen und der Quantencomputer könnte die Zielfunktion effizient berechnen. Dieser hybride Ansatz könnte sich als attraktiv erweisen, um Probleme zu lösen, die selbst mit Dichtefunktionaltheorie (DFT) oder Hartree-Fock-Näherungen nicht gelöst werden können.

So sieht es mit Classiq aus:

‍

Verwenden wir Classiq, um ein Grundzustandsproblem für das Molekül H2 zu lösen, und beginnen wir mit unserem Python-SDK. Dazu wird ein Hamiltonian generiert, ein Variationsquantenschaltkreis zur Berechnung des Grundzustands des Hamiltonian erstellt und dieser Schaltkreis in einem hybriden quantenklassischen VQE-Algorithmus ausgeführt.

Hier definieren wir das Problem als H2-Molekül, indem wir die Classiq-Atombibliothek verwenden und deren Position, Ladung und Spin angeben. Dieser Codeblock endet mit der Generierung des Hamiltonianers.


from classiq importieren ModelDesigner, Ausführendes Programm
from classiq.builtin_functions importieren UCC, HartreeFock

from classiq.interface.chemistry.molecule importieren Molekül
from classiq.interface.chemistry.ground_state_problem importiere GroundStateProblem
from classiq.interface.backend.backend_preferences importieren 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


Molekül = Molekül(
    atoms=[
        ("H", (0.0, 0.0, 0.0)),
        ("H", (0.0, 0.0, 3.0)),
        ],
)
gs_problem = Grundzustands-Problem(
    Molekül=Molekül,
    mapping="jordan_wigner",
)

Operator = gs_problem.generate_hamiltonian()

Nun erstellen wir einen Ansatz oder eine anfängliche parametrisierte Schätzung für unseren VQE-Algorithmus, indem wir den erzeugten Hamiltonian verwenden. Dieser Abschnitt des Codes erstellt eine hardware-effiziente Quantenschaltung zur Darstellung des Ansatzes. Die Classiq-Plattform synthetisiert Quantenschaltungen in vielen Sprachen, standardmäßig in 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

Zuletzt führen wir den VQE-Algorithmus aus, wobei wir 30 Mal iterieren und den QASM-Code aus dem vorherigen Abschnitt als Eingabe verwenden und angeben, dass der Algorithmus vom IBMQ-Aer-Simulator ausgeführt wird.


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),
    hamiltonian=Operator
)
result = Executor(
    preferences=execution_preferences
).execute_hamiltonian_minimization(hamiltonian_problem)

print("Die Grundzustandsenergie von H2 ist", result.energy)
print("Die optimalen Parameter für den Ansatz sind", result.optimal_parameters)
result.show_convergence_graph()

‍

Es werden die Grundzustandsenergie und die optimalen Parameter ausgegeben. Diese Parameter entsprechen den Winkeln im Ansatz, und unser Konvergenzdiagramm zeigt, wie der Algorithmus die richtige Lösung gefunden hat.

Wir können den gleichen Prozess auch mit unserem Textmodell durchführen, indem wir einfach den folgenden Code ausführen.


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

‍

Möchten Sie sehen, was die Classiq-Plattform für Ihr Unternehmen leisten kann? Kontaktieren Sie uns, um eine Demo zu vereinbaren

Quantencomputer können helfen. Anstatt "grobkörnige" Annäherungen auf klassischen Computern durchzuführen, können Wissenschaftler auf Quantencomputern viel präzisere Simulationen durchführen.

So sieht es mit Classiq aus:

‍


from classiq importieren ModelDesigner, Ausführendes Programm
from classiq.builtin_functions importieren UCC, HartreeFock

from classiq.interface.chemistry.molecule importieren Molekül
from classiq.interface.chemistry.ground_state_problem importiere GroundStateProblem
from classiq.interface.backend.backend_preferences importieren 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


Molekül = Molekül(
    atoms=[
        ("H", (0.0, 0.0, 0.0)),
        ("H", (0.0, 0.0, 3.0)),
        ],
)
gs_problem = Grundzustands-Problem(
    Molekül=Molekül,
    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),
    hamiltonian=Operator
)
result = Executor(
    preferences=execution_preferences
).execute_hamiltonian_minimization(hamiltonian_problem)

print("Die Grundzustandsenergie von H2 ist", result.energy)
print("Die optimalen Parameter für den Ansatz sind", result.optimal_parameters)
result.show_convergence_graph()

‍

Wir können den gleichen Prozess auch mit unserem Textmodell durchführen, indem wir einfach den folgenden Code ausführen.


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

‍

Möchten Sie sehen, was die Classiq-Plattform für Ihr Unternehmen leisten kann? Kontaktieren Sie uns, um eine Demo zu vereinbaren

Über "Der Podcast des Qubit-Typen"

Der Podcast wird von The Qubit Guy (Yuval Boger, unser Chief Marketing Officer) moderiert. In ihm diskutieren Vordenker der Quanteninformatik über geschäftliche und technische Fragen, die das Ökosystem der Quanteninformatik betreffen. Unsere Gäste geben interessante Einblicke in Quantencomputer-Software und -Algorithmen, Quantencomputer-Hardware, Schlüsselanwendungen für Quantencomputer, Marktstudien der Quantenindustrie und vieles mehr.

Wenn Sie einen Gast für den Podcast vorschlagen möchten, kontaktieren Sie uns bitte .