Blog

Schaltung des Monats November 2021: Spaß bei den State Preparations

8
November
,
2021

Die Vorbereitung von Zuständen ist oft ein wichtiger erster Schritt in vielen Quantenalgorithmen. In diesem Monat untersuchen wir eine Schaltung, die Wahrscheinlichkeitsfunktionen in fünf Gruppen von je drei Qubits lädt.

Einzigartig ist hier die Art und Weise, wie die Classiq-Plattform die Schaltung generiert, wenn eine unterschiedliche Anzahl von Qubits zur Verfügung steht.

Im ersten Fall bitten wir die Syntheseplattform, dieses Ziel mit 20 Qubits zu erreichen. Nachdem sie automatisch viele Optionen untersucht hat, entscheidet sie, dass eine gute Lösung darin besteht, die 20 Qubits in fünf Gruppen zu je vier Qubits aufzuteilen. In jeder Gruppe werden drei Qubits initialisiert und das vierte Qubit wird als Hilfs-Qubit verwendet.

Noch interessanter wird es, wenn die Classiq-Maschine eine Lösung mit 16 Qubits finden soll. In diesem Fall sind fünf Gruppen mit je vier Qubits nicht möglich. Die Maschine generiert eine Lösung mit den folgenden Schritten:

  • Zunächst werden vier Gruppen von drei Qubits initialisiert (jeweils mit einem Ancilla-Qubit)
  • Dann werden die vier ancialla-Qubits (eines aus jeder Gruppe) bereinigt
  • Für die letzte Gruppe von drei Qubits, die noch nicht initialisiert wurde, werden drei dieser vier Qubits (die zuvor als Ancilla-Qubits für die vorherigen Gruppen verwendet wurden) initialisiert, wobei das vierte Qubit als Ancilla verwendet wird

Hier ist der Classiq-Code für den 20-qubit-Fall. Dies ist das textuelle Modell, das man in der VSCode-Umgebung ausführen könnte:


{
    "qubit_count":  20,
    "max_depth":1000,
    "draw_as_functions": false,
    "output_format": ["qasm"],
    "logic_flow": [{
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.2, 0.05, 0.3, 0.0, 0.0, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.3}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.2, 0.05, 0.0, 0.3, 0.0, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.32}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.0, 0.05, 0.3, 0.0, 0.2, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.32}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.0, 0.2, 0.05, 0.3, 0.0, 0.0, 0.05]
            },
            "error_metric": {"KL": {"upper_bound": 0.34}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.2, 0.0, 0.35, 0.0, 0.0, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.3}}
        },
        "add_as_single_gate": true
    }
]
}

und hier ist die resultierende Schaltung. Sie können sehen, dass alle fünf Gruppen (jeweils drei Qubits) parallel initialisiert werden

20-Qubit-Schaltung

Um die 16-Qubit-Lösung zu untersuchen, muss eine einzige Zeile geändert werden:


{
    "qubit_count":  16, // <-- this is the only line that has changed
    "max_depth":1000,
    "draw_as_functions": false,
    "output_format": ["qasm"],
    "logic_flow": [{
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.2, 0.05, 0.3, 0.0, 0.0, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.3}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.2, 0.05, 0.0, 0.3, 0.0, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.32}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.0, 0.05, 0.3, 0.0, 0.2, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.32}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.0, 0.2, 0.05, 0.3, 0.0, 0.0, 0.05]
            },
            "error_metric": {"KL": {"upper_bound": 0.34}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.2, 0.0, 0.35, 0.0, 0.0, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.3}}
        },
        "add_as_single_gate": true
    }
]
}

Und hier ist die resultierende Schaltung. Man kann sehen, dass die Qubits 3, 7, 11 und 15 verwendet werden, nachdem die Zustandsvorbereitung der Qubits 0-2, 4-6, 8-10 und 12-14 abgeschlossen ist:

16-Qubit-Lösung

Die Classiq-Plattform ermöglicht es Designern nicht nur, verschiedene Möglichkeiten zu erkunden, sondern findet auch automatisch innovative Lösungen.

Die Vorbereitung von Zuständen ist oft ein wichtiger erster Schritt in vielen Quantenalgorithmen. In diesem Monat untersuchen wir eine Schaltung, die Wahrscheinlichkeitsfunktionen in fünf Gruppen von je drei Qubits lädt.

Einzigartig ist hier die Art und Weise, wie die Classiq-Plattform die Schaltung generiert, wenn eine unterschiedliche Anzahl von Qubits zur Verfügung steht.

Im ersten Fall bitten wir die Syntheseplattform, dieses Ziel mit 20 Qubits zu erreichen. Nachdem sie automatisch viele Optionen untersucht hat, entscheidet sie, dass eine gute Lösung darin besteht, die 20 Qubits in fünf Gruppen zu je vier Qubits aufzuteilen. In jeder Gruppe werden drei Qubits initialisiert und das vierte Qubit wird als Hilfs-Qubit verwendet.

Noch interessanter wird es, wenn die Classiq-Maschine eine Lösung mit 16 Qubits finden soll. In diesem Fall sind fünf Gruppen mit je vier Qubits nicht möglich. Die Maschine generiert eine Lösung mit den folgenden Schritten:

  • Zunächst werden vier Gruppen von drei Qubits initialisiert (jeweils mit einem Ancilla-Qubit)
  • Dann werden die vier ancialla-Qubits (eines aus jeder Gruppe) bereinigt
  • Für die letzte Gruppe von drei Qubits, die noch nicht initialisiert wurde, werden drei dieser vier Qubits (die zuvor als Ancilla-Qubits für die vorherigen Gruppen verwendet wurden) initialisiert, wobei das vierte Qubit als Ancilla verwendet wird

Hier ist der Classiq-Code für den 20-qubit-Fall. Dies ist das textuelle Modell, das man in der VSCode-Umgebung ausführen könnte:


{
    "qubit_count":  20,
    "max_depth":1000,
    "draw_as_functions": false,
    "output_format": ["qasm"],
    "logic_flow": [{
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.2, 0.05, 0.3, 0.0, 0.0, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.3}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.2, 0.05, 0.0, 0.3, 0.0, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.32}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.0, 0.05, 0.3, 0.0, 0.2, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.32}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.0, 0.2, 0.05, 0.3, 0.0, 0.0, 0.05]
            },
            "error_metric": {"KL": {"upper_bound": 0.34}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.2, 0.0, 0.35, 0.0, 0.0, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.3}}
        },
        "add_as_single_gate": true
    }
]
}

und hier ist die resultierende Schaltung. Sie können sehen, dass alle fünf Gruppen (jeweils drei Qubits) parallel initialisiert werden

20-Qubit-Schaltung

Um die 16-Qubit-Lösung zu untersuchen, muss eine einzige Zeile geändert werden:


{
    "qubit_count":  16, // <-- this is the only line that has changed
    "max_depth":1000,
    "draw_as_functions": false,
    "output_format": ["qasm"],
    "logic_flow": [{
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.2, 0.05, 0.3, 0.0, 0.0, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.3}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.2, 0.05, 0.0, 0.3, 0.0, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.32}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.0, 0.05, 0.3, 0.0, 0.2, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.32}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.0, 0.2, 0.05, 0.3, 0.0, 0.0, 0.05]
            },
            "error_metric": {"KL": {"upper_bound": 0.34}}
        },
        "add_as_single_gate": true
    },
    {
        "function": "StatePreparation",
        "function_params": {
            "num_qubits": 4,
            "probabilities": {
                "pmf": [0.4, 0.05, 0.2, 0.0, 0.35, 0.0, 0.0, 0.0]
            },
            "error_metric": {"KL": {"upper_bound": 0.3}}
        },
        "add_as_single_gate": true
    }
]
}

Und hier ist die resultierende Schaltung. Man kann sehen, dass die Qubits 3, 7, 11 und 15 verwendet werden, nachdem die Zustandsvorbereitung der Qubits 0-2, 4-6, 8-10 und 12-14 abgeschlossen ist:

16-Qubit-Lösung

Die Classiq-Plattform ermöglicht es Designern nicht nur, verschiedene Möglichkeiten zu erkunden, sondern findet auch automatisch innovative Lösungen.

Ü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 .

Siehe auch

Keine Artikel gefunden.

Erstellen Sie Quantensoftware ohne Grenzen 

Kontakt