HomeZufallszahlen: Klassisch vs. QuantumNewsBlogZufallszahlen: Klassisch vs. Quantum

Zufallszahlen: Klassisch vs. Quantum

Einleitung

Habt ihr euch jemals gefragt, wie man mit einem Quantencomputer einen Würfel wirft[1] oder Zufallszahlen erzeugt? Zufallszahlen sind in vielen Bereichen, von Computerspielen bis hin zu verschlüsselten Nachrichten, von zentraler Bedeutung. Während wir alle mit der traditionellen Methode der Zufallsgenerierung auf klassischen Computern vertraut sind, bietet die Quantenprogrammierung eine ganz neue Perspektive. Lass uns den Unterschied zwischen klassischer und quantenmäßiger Programmierung anhand dieses Beispiels betrachten. In diesem Beitrag werde ich euch durch den Prozess führen und zeigen, wie Zufallszahlen mit Hilfe von Qiskit erzeugt werden.

Klassische Computer

Klassische Computer erzeugen „pseudo-zufällige“ Zahlen, die bei gleichem Startwert immer dieselbe Sequenz von Zahlen produzieren. Dies geschieht, weil diese Zufallsgenerierung auf algorithmisch erzeugten Sequenzen wie dem linearen Kongruenzgenerator (LCG) oder dem Mersenne-Twister basiert.

Im Gegensatz dazu verhalten sich Quantencomputer anders. Sie nutzen die inhärente Unvorhersehbarkeit der Quantenmechanik, um tatsächlich zufällige Zahlen zu generieren. Diese echte Zufälligkeit könnte in vielen Bereichen, in denen absolute Unvorhersehbarkeit von großer Bedeutung ist, eine Revolution auslösen. Dieser Fortschritt wäre ein echter Mehrwert, da die Zufälligkeit, die von Quantencomputern erzeugt wird, fundamental anders ist als die algorithmisch gesteuerte Zufallsgenerierung.

In der klassischen Programmierung, insbesondere mit der Sprache Python, gibt es spezielle Module, die für die Erzeugung von Zufallszahlen verwendet werden können. Ein solches Modul ist das random-Modul

Python-Beispiel: In Python kann man das random-Modul verwenden, um Zufallszahlen zu generieren. Dieses Modul bietet verschiedene Funktionen, um Zahlen innerhalb bestimmter Bereiche oder sogar zufällige Elemente aus Listen zu wählen. Es ist ein nützliches Werkzeug, das in vielen Anwendungen, von Spielen bis hin zu wissenschaftlichen Simulationen, eingesetzt wird.

import numpy as np
import random
random.seed()
# Generate 5 random numbers between 1 and 6
random_numbers = [random.randint(1, 6) for _ in range(5)]
random_numbers

Quantum-Zufallszahlen

Nachdem wir gesehen haben, wie klassische Computer Zufallszahlen erzeugen, schauen wir uns jetzt die Quantenwelt an. Hierfür nutzen wir Qiskit um auf einem IBM-Quantencomputer mit 27 QBit zu arbeiten.

Erst simulieren, dann echt ausprobieren

Bevor wir unsere Qubit-Maschine auf einem echten Quantencomputer testen, probieren wir sie auf einem Simulator aus. Das ist wie ein Übungsplatz, um sicherzugehen, dass alles klappt, da der Zugriff auf echte Quantencomputer begrenzt ist und die Nutzung von Quantencomputern teuer ist.

Zu Beginn definieren wir einen Circuit mit drei Qubits. Dann nutzen wir einen speziellen Befehl, das Hadamard-Gate, um die Qubits in eine Superposition zu versetzen. Das bedeutet, dass sie mehrere Zustände gleichzeitig annehmen können. Nach dieser Aktion messen wir das Ergebnis der Qubits.

Der nächste Schritt ist die Ausführung des Circuits. Hierfür nutzen wir einen Simulator namens aer_simulator. Nachdem der Circuit ausgeführt wurde, konvertieren wir das binäre Ergebnis in eine Ganzzahl.

Schließlich rufen wir die Funktion quantum_random_number fünfmal auf, um fünf zufällige Zahlen zwischen 1 und 6 zu erhalten und diese auszugeben.

Qiskit-Beispiel:

def quantum_random_number():
               # Define quantum circuit mit 3 qubits
               qc = QuantumCircuit(3)
               # Apply a Hadamard gate to put the qubit in superposition
               qc.h([0,1,2])
               # Measure the qubit
               qc.measure_all()
               # Execute the quantum circuit
               aer_sim = Aer.get_backend(‚aer_simulator‘)
               t_qc = transpile(qc, aer_sim)
               qobj = assemble(t_qc)
               result = execute(qc, aer_sim).result()
               counts = result.get_counts(qc)
               # Convert the binary outcome to an integer
               random_number = int(list(counts.keys())[0], 2)
               return random_number
# Get 5 random numbers between 1 and 6
random_numbers = [quantum_random_number() % 6 + 1 for _ in range(5)]
print(random_numbers)

Vom Simulator zum echten Quantencomputer

Nachdem wir unseren Code im Simulator getestet haben, probieren wir ihn auf einem echten IBM Quantencomputer aus. Um unseren Code auf einem echten IBM Quantencomputer auszuführen, müssen wir lediglich den Backend von ‚aer_simulator‘ auf den gewünschten IBM Quantencomputer ändern.

from qiskit import IBMQ
IBMQ.save_account(‚YOUR_API_TOKEN‘)
# Load your IBM Q account
IBMQ.load_account()
provider = IBMQ.get_provider(‚ibm-q‘)
backend = provider.get_backend(‚ibmq_16_melbourne‘)  # Choose an appropriate backend
def quantum_random_number():
               # Define a three qubit quantum circuit
               qc = QuantumCircuit(3)
               # Apply a Hadamard gate to put the qubits in superposition
               qc.h([0,1,2])
               # Measure the qubits
               qc.measure_all()
               # Transpile and assemble for the chosen backend
               t_qc = transpile(qc, backend=backend)
               qobj = assemble(t_qc)
               # Execute the quantum circuit on the quantum computer
               result = execute(qc, backend=backend, shots=1).result()
               counts = result.get_counts(qc)
               # Convert the binary outcome to an integer
               random_number = int(list(counts.keys())[0], 2)
               return random_number
# Get 5 random numbers between 1 and 6
random_numbers = [quantum_random_number() % 6 + 1 for _ in range(5)]
print(random_numbers)

Cirq Beispiel:

In Cirq definieren wir, ähnlich wie in Qiskit, einen Circuit und fügen ihm Qubits hinzu. Dann wenden wir Gates an, in unserem Fall das Hadamard-Gate, um die Qubits in eine Superposition zu versetzen. Nachdem der Circuit definiert ist, können wir ihn mit einem Simulator ausführen und die Ergebnisse analysieren.

Hier ist ein einfacher Code, um mit Cirq einen Quantenwürfel zu simulieren:

import cirq
def quantum_random_number():
    # Define three qubits
    qubits = [cirq.GridQubit(0, i) for i in range(3)]
    # Create a circuit
    circuit = cirq.Circuit()
    # Apply a Hadamard gate to put the qubits in superposition
    circuit.append(cirq.H(q) for q in qubits)
    # Measure the qubits
    circuit.append(cirq.measure(*qubits, key=’result‘))
    # Simulate the circuit
    simulator = cirq.Simulator()
    result = simulator.run(circuit, repetitions=1024)
    counts = result.histogram(key=’result‘)
    # Get the most frequent outcome
    most_frequent = counts.most_common(1)[0][0]
    return most_frequent
# Get 5 random numbers between 1 and 6
random_numbers = [quantum_random_number() % 6 + 1 for _ in range(5)]
print(random_numbers)

[1] Idea von: https://youtu.be/AlOhEu6DILA

AI ready for business

AImpacts – Ihre Experten, wenn es darum geht, Ihr Unternehmen mit AI zukunftsfähig zu machen.

Optimized with PageSpeed Ninja