Über den Tellerrand der Zustandsvorbereitungen schauen - Classiq zur Erzeugung von Schaltkreisen mit Log-Normal-Verteilung der Tiefe 1 

Diese Notiz zeigt, wie die Classiq-Plattform genutzt werden kann, um das Log-Normal-Zustandsvorbereitungsproblem aus unserem jüngsten Programmierwettbewerb zu lösen. Wir untersuchen zwei Methoden zur Erzeugung dieser Zustandsvorbereitung sowie den Trick, der zur Erzeugung einer Zustandsvorbereitung mit einer Schaltungstiefe von 1 erforderlich ist. 

Schritt 1 für alle Quantenalgorithmen

Zustandsvorbereitungen sind ein integraler Bestandteil der Quantenberechnungen, wobei fast alle Quantenanwendungen mit der Vorbereitung eines Zustands in einem Quantenregister beginnen. Im Finanzwesen kann der Zustand zum Beispiel die Preisverteilung bestimmter Vermögenswerte als Teil eines Portfolio-Optimierungsalgorithmus darstellen. In der Chemie kann er eine erste Schätzung für den Grundzustand eines Moleküls sein, und beim maschinellen Lernen mit Quanten ist er der zu analysierende Merkmalsvektor.

Unter Zustandsvorbereitung versteht man die Initialisierung von Qubits mit Quantengattern, so dass ihr gemessener Ausgang einer gewünschten Wahrscheinlichkeitsverteilung entspricht. Dieser initialisierte Zustand kann dann von nachfolgenden Quantenschaltungen zur Durchführung von Berechnungen verwendet werden. Die Log-Normal-Zustandsvorbereitung, die wir besprechen werden, ist ein häufig verwendeter initialisierter Zustand in vielen Finanzberechnungen. 

Das Log-Normal-Zustandsvorbereitungsproblem

In unserem jüngsten Kodierwettbewerb wurden die Teilnehmer aufgefordert, eine Schaltung zu entwerfen, die eine Lognormalverteilung mit einem Mittelwert (µ) von 0 und einer Standardabweichung (σ) von 0,1 erzeugt und dabei nicht mehr als 10 Qubits verwendet. Die Schaltung muss eine Lognormalverteilung mit einem Fehler von höchstens 0,01 approximieren und darf nur "u"- und "CX"-Gatter enthalten. Gewonnen hat die Schaltung mit der geringsten Tiefe, die alle oben genannten Kriterien erfüllt.

Dieses Problem war sowohl das schwierigste zu lösende als auch das am einfachsten zu berechnende der vier von uns entworfenen Wettbewerbsaufgaben. Um unseren Konkurrenten einen Hinweis darauf zu geben, wie sie dieses Problem angehen sollten, verlangten wir von ihnen, sowohl die Quantenschaltung als auch die von ihnen verwendete Diskretisierungsmethode einzureichen.

Lösen von Zustandsvorbereitungen mit Classiq

Um mit Classiq eine Zustandsvorbereitung zu erzeugen, rufen wir die Funktion "StatePreparation" auf und geben die Wahrscheinlichkeiten der Schaltung, die Anzahl der Qubits und die obere Fehlergrenze an. Wir wissen, dass die maximale Anzahl von Qubits 10 beträgt, dass wir eine Log-Normal-Verteilung eingeben müssen und dass der Gesamtfehler des Schaltkreises (der mathematische Fehler bei der Annäherung an eine Log-Normal-Verteilung plus der Fehler bei der Übersetzung in einen Quantenschaltkreis) 0,01 nicht überschreiten sollte. Sobald diese wenigen Parameter definiert sind, implementiert die Classiq-Plattform die Quantenschaltung. So einfach ist das. Nachfolgend finden Sie den Code zur Generierung dieses Schaltkreises mit dem Python-SDK von Classiq, obwohl ein entsprechender Schaltkreis auch mit der Classiq-Erweiterung in Visual Studio Code generiert werden kann. 

import classiq
from classiq import ModelDesigner
from classiq.builtin_functions import StatePreparation

# Given variables
TARGET_ERR = 1e-2
SIGMA = 0.1
N_QUBITS = 10

# Calculated probability distribution and error bound
# Set flag to False for unequal partition of the 'x' axis
lognorm_probabilities, _, l2_error_upper_bound, _ = partition(n_qubits=N_QUBITS, flag=True) 

# State preparation parameters
sp_params = StatePreparation(probabilities=lognorm_probabilities, 
                             num_qubits=N_QUBITS, 
                             error_metric={"L2": {"upper_bound": l2_error_upper_bound}})

# Circuit Synthesis
model_designer = ModelDesigner()
model_designer.StatePreparation(params=sp_params)
circuit = model_designer.synthesize()

Der Schlüssel zur Lösung dieses Problems liegt in der Vorgehensweise bei der Implementierung dieser Verteilung. Die direkte und einfache Lösung für dieses Problem besteht darin, eine Teilmenge des Bereichs auszuwählen, die auf dem Mittelwert der Verteilung zentriert ist, unsere Diskretisierung gleichmäßig über die verfügbaren Bins innerhalb dieses Bereichs zu verteilen (bei 10 Qubits haben wir²¹⁰ Bins) und den Rest des Bereichs zu vernachlässigen. Die Wahrscheinlichkeiten innerhalb dieser²¹⁰ Bins unserer Domänenuntermenge können dann so geändert werden, dass sie einer Log-Normal-Verteilung entsprechen. Zur Definition unseres Schaltkreises muss lediglich diese Wahrscheinlichkeitsmassenfunktion in die Classiq-Plattform geladen und unsere Fehlerschwelle ausgewählt werden. Nach dieser Methode hat die Classiq-Plattform (unter Verwendung von Version 0.15) eine 242-stufige Sch altung für uns implementiert. Die folgende interaktive Schaltung finden Sie hier.

Der Trick

Es gibt jedoch auch einen anderen Ansatz dafür. Bei der Durchführung einer Zustandsvorbereitung können zwei Parameter eingestellt werden: die zu ladenden Wahrscheinlichkeiten und die Diskretisierungsmethode, die zur Berechnung der Ergebnisse verwendet wird. Bei der bisherigen Methode wurde für die Diskretisierung ein Standard mit linearen Abständen verwendet. Dies machte es erforderlich, Wahrscheinlichkeiten zu laden, die der gewünschten lognormalen Verteilung entsprechen. 

Was würde also passieren, wenn ein nichtlinearer Diskretisierungsabstand gewählt würde? Wenn wir die Abstände für unsere²¹⁰ Bins intelligent wählen, können wir eine Schaltung aufbauen, bei der alle geladenen Wahrscheinlichkeiten identisch sind. Dies könnte die nachfolgenden Berechnungen für diesen Quantenschaltkreis erschweren, aber es würde den Aufbau der Zustandsvorbereitung trivial machen. Wir können nun die Messbasis für unsere Qubits frei wählen und sie alle mit der gleichen Wahrscheinlichkeit in dieser Basis vorbereiten. Wenn wir z. B. die Basis $|+\rangle$ wählen, können wir alle unsere Qubits mit Hadamard-Gattern präparieren, was zu einer Schaltung mit einer Tiefe von 1 führt, die unten zu sehen und hier verfügbar ist.

Wir waren erfreut zu sehen, dass die Gewinner dieses Wettbewerbsproblems in der Lage waren, diesen Trick zu erkennen, wobei jeder seine eigene Diskretisierungsauswahlmethode verwendete. Dieses Problem soll zeigen, dass es nicht nur technisches Wissen braucht, um effiziente Quantenschaltungen zu erzeugen, sondern dass auch Kreativität erforderlich ist, um effiziente Quantenschaltungen zu erzeugen. Um unsere Diskretisierung zu erzeugen, definieren wir zwei Funktionen: eine zur Berechnung des L2-Fehlers und die andere zur Erzeugung der Diskretisierung unter Berücksichtigung des L2-Fehlers. Unser Code ist unten eingefügt.

from scipy.stats import lognorm
von scipy.interpolate importieren interp1d
import numpy as np

# L2-Fehlerberechnung
def l2_error(pmf: np.array, x_grid: np.array, sigma=0.1):
    pmf = np.array(pmf)
    x_grid = np.array(x_grid)
    assert all(pmf >= 0)
    assert np.isclose(sum(pmf), 1)
    assert all(x_grid >= 0)
    prüfen all(np.diff(x_grid) > 0)
    assert len(pmf) + 1 == len(x_grid)

    n_punkt = 2 ** 22
    tail_value = (TARGET_ERR / 100) ** 2
    min_x = lognorm.ppf(tail_value, sigma)
    max_x = lognorm.ppf(1 - tail_value, sigma)
    x_middle = np.linspace(min_x, max_x, n_point)
    x_unterer_Schwanz = np.linspace(0, min_x, n_punkt // 1000)
    x_oberer_Schwanz = np.linspace(max_x, x_grid[-1], n_point // 1000) if x_grid[-1] > max_x else np.array([])

    x_approx = np.diff(x_grid) / 2 + x_grid[:-1]
    x_approx = np.concatenate(([x_approx[0]], x_approx, [x_approx[-1]]))
    pdf_approx = pmf / np.diff(x_grid)
    pdf_approx = np.concatenate(([pdf_approx[0]], pdf_approx, [pdf_approx[-1]]))

    fy = interp1d(x_approx, pdf_approx, kind='nearest', assume_sorted=True, fill_value=(0, 0), bounds_error=False)
    x_full = np.concatenate((x_lower_tail[:-1], x_middle, x_upper_tail[1:]))
    approx_pdf = fy(x_full)

    full_pdf = lognorm.pdf(x_full, sigma)
    dx = np.diff(x_voll)
    dx = np.append(dx, 0)

    upper_tail_err_2_approx = lognorm.sf(x_full[-1], sigma)
    main_err_2 = sum((full_pdf - approx_pdf) ** 2 * dx)
    err = (oberer_Schwanz_err_2_approx + main_err_2) ** 0.5
    Rückgabe err

# Berechnung der Wahrscheinlichkeitsverteilung auf der Grundlage der gewählten Diskretisierungsmethode
def partition(n_qubits=10, flag=True):
    bins = 2 ** n_qubits
    tail_value = (TARGET_ERR / 10) ** 2
    if flag:
        x_discrete = np.linspace(lognorm.ppf(tail_value, SIGMA),
                               lognorm.ppf(1 - tail_value, SIGMA), bins + 1)
    sonst:
        x_discrete = lognorm.ppf(np.linspace(tail_value, 1 - tail_value, bins + 1), SIGMA)
    pmf = np.diff(lognorm.cdf(x_diskret, SIGMA))
    pmf = pmf / sum(pmf)
    ERR = l2_error(pmf, x_diskret, sigma=SIGMA)
    Spanne = TARGET_ERR - ERR
    assert margin > 0
    return tuple(pmf), x_discrete, margin, ERR

Wie dies im Vergleich zu den Lösungen der Wettbewerber aussieht, erfahren Sie hier.

Jenseits von Log-Normal-Verteilungen

Classiq macht die Erstellung einer Zustandsvorbereitung einfach. Definieren Sie die Wahrscheinlichkeiten, mit denen Ihr Schaltkreis initiiert werden soll, und die Plattform kümmert sich um den Rest. Classiq ermöglicht die flexible Definition von Wahrscheinlichkeiten entweder als Wahrscheinlichkeitsmassenfunktion oder als Gaußsche Mischung und bietet mehrere Methoden zur Definition des zulässigen Fehlers für den Schaltkreis, wie KL, L1, L2, maximale Wahrscheinlichkeit und Verlust der Wiedergabetreue. Hier ist ein Beispiel für Classiq zur Implementierung einer Zustandsvorbereitung unter Verwendung von Gaußschen Momenten, und hier ist ein Beispiel für einen Algorithmus zur Kreditrisikoanalyse, der ein Gaußsches Moment für seine Zustandsvorbereitung verwendet. 

Die Zustandsvorbereitung von Classiq ist flexibel, einfach zu programmieren und generiert die gewünschte Schaltung automatisch, ganz gleich, ob Sie die Ergebnisse einer wissenschaftlichen Arbeit replizieren oder neuartige Quantenalgorithmen entwickeln. Wie wir bei Classiq sagen : "Es ist einfach zu definieren, was man will, aber es zu implementieren ist schwierig". Lassen Sie also die Classiq-Plattform Ihre definierten Schaltkreise implementieren. Classiq-Kunden arbeiten auf einer höheren Ebene. Sie geben die gewünschte Funktionalität der Schaltung sowie die geltenden Einschränkungen an, und die Classiq-Plattform findet automatisch die richtige Implementierung aus Milliarden von Designraum-Optionen.

Vereinbaren Sie einen Termin für eine Live-Demonstration der Classiq-Plattform, um sie in Aktion zu erleben, oder nehmen Sie Kontakt mit uns auf, um zu erfahren, wie Sie in wenigen Minuten branchenführende Quantenschaltungen erstellen können.