Wie würde ein sehr einfaches Quantenprogramm aussehen?

15

Nach dem Lesen des " ersten programmierbaren Quantenphotonen-Chips ". Ich habe mich gefragt, wie Software für einen Computer mit Quantenverschränkung aussehen würde.

Gibt es ein Codebeispiel für eine bestimmte Quantenprogrammierung? Wie Pseudocode oder Hochsprache? Was ist das kürzeste Programm, mit dem ein Bell-Status erstellt werden kann ausgehend von einem Zustand initialisiertunter Verwendungsowohl eine Simulation und einer von IBMQuantum ExperienceProzessoren, wie beispielsweise dieibmqx4?

| ψ ⟩ = \frac{1}{\sqrt{2}} (| 00 ⟩ + | 11 ⟩)

$\left|\psi\right> = \frac{1}{\sqrt 2} \left(\left|00\right> + \left|11\right> \right)$

| ψ_{0} ⟩ = | 00 ⟩

$\left|\psi_0\right> = \left|00\right>$

Den konzeptionellen Sprung von der traditionellen Programmierung zur Verschränkung zu schaffen, ist nicht so einfach.

Ich habe auch C's Libquantum gefunden .

simulation ibm-q-experience programming

— DIDIx13
quelle

12

Angenommen, Sie überlegen sich einen Quantencomputer auf Gate-Basis. Der einfachste Weg, einen verschlungenen Zustand zu erzeugen, besteht darin, einen der Bell-Zustände zu erzeugen. Die folgende Schaltung zeigt den Glockenzustand . $\left| \Phi^+ \right>$

Durch die Prüfung , und können wir die gewärmte Zustand nach Anwendung aller Tore bestimmen: $\left| \psi_0 \right>$ $\left| \psi_1 \right>$ $\left| \psi_2 \right>$

1. : $\left| \psi_0 \right>$

| ψ_{0} ⟩ = | 00 ⟩

$\left| \psi_0 \right> = \left | 0 0 \right >$

$\left| \psi_1 \right>$

Das Hadamard-Gate gilt für das erste Qubit, was zu folgenden Ergebnissen führt:

| ψ_{1} ⟩ = (H \otimes ich) | 00 ⟩ = H | 0 ⟩ \otimes | 0 ⟩ = \frac{1}{\sqrt{2}} (| 0 ⟩ + | 1 ⟩) | 0 ⟩ = \frac{1}{\sqrt{2}} (| 00 ⟩ + | 10 ⟩)

$\left| \psi_1 \right> =(H \otimes I)\left | 0 0 \right > = H\left | 0 \right > \otimes \left | 0 \right > = \frac{1}{\sqrt 2} \left (\left | 0 \right > + \left | 1 \right > \right ) \left | 0 \right > = \frac{1}{\sqrt 2} \left (\left | 0 0 \right > + \left | 1 0 \right > \right )$

$\left| \psi_2 \right>$

Nun wird ein CNOT-Gatter angelegt und kippt das zweite Qubit, jedoch nur dort, wo das erste den Wert 1 hat. Das Ergebnis ist

| ψ_{2} ⟩ = \frac{1}{\sqrt{2}} (| 00 ⟩ + | 11 ⟩)

$\left| \psi_2 \right> = \frac{1}{\sqrt 2} \left (\left | 0 0 \right > + \left | 1 1 \right > \right )$

$\left| \psi_2 \right>$

Obwohl Ihnen der obige Ansatz nicht so vorkommt, als würden Sie normalerweise programmieren, funktioniert das Programmieren eines gate-basierten Quantencomputers im Grunde genommen, wenn Sie Gates auf Status anwenden. Es gibt Abstraktionsebenen, mit denen Sie eine übergeordnete Programmierung durchführen, die Befehle jedoch in die Anwendung von Gates übersetzen können. Die IBM Quantum Experience- Schnittstelle bietet solche Funktionen.

In einer Sprache wie Microsoft's Q # könnte das obige Beispiel ungefähr so aussehen:

operation BellTest () : ()
{
    body
    {
        // Use two qubits
        using (qubits = Qubit[2])
        {
            Set (One, qubits[0]);
            Set (Zero, qubits[1]);

            // Apply Hadamard gate to the first qubit
            H(qubits[0]);

            // Apply CNOT gate
            CNOT(qubits[0],qubits[1]);
         }
     }
}

Eine ausführlichere Version (einschließlich Messung) finden Sie hier: Microsoft: Writing a Quantum Program .

— dtell
quelle

14

Eine Möglichkeit zum Schreiben von Quantenprogrammen ist QISKit. Auf diese Weise können die Programme auf IBM Geräten ausgeführt werden. Die QISKit-Website schlägt den folgenden Codeausschnitt vor, um Sie zum Laufen zu bringen. Es ist auch der gleiche Vorgang wie bei der Antwort per Datell. Ich werde es Zeile für Zeile kommentieren.

# import and initialize the method used to store quantum programs
from qiskit import QuantumProgram
qp = QuantumProgram()
# initialize a quantum register of two qubits
qr = qp.create_quantum_register('qr',2) 
# and a classical register of two bits
cr = qp.create_classical_register('cr',2) 
# create a circuit with them which we call 'Bell'
qc = qp.create_circuit('Bell',[qr],[cr]) 
# apply a Hadamard to the first qubit
qc.h(qr[0]) 
# apply a controlled not with the first qubit as control
qc.cx(qr[0], qr[1]) 
# measure the first qubit and store its result on the first bit
qc.measure(qr[0], cr[0]) 
# the same for the second qubit and bit
qc.measure(qr[1], cr[1]) 
# run the circuit
result = qp.execute('Bell') 
# extract the results
print(result.get_counts('Bell'))

Beachten Sie, dass der Befehl 'execute' hier nur das auszuführende Programm angibt. Alle anderen Einstellungen, z. B. das Gerät, das Sie verwenden möchten, die Häufigkeit, mit der Sie es wiederholen möchten, um Statistiken abzurufen usw., werden auf ihre Standardwerte gesetzt. Um auf ibmqx4 für 1024 Aufnahmen zu laufen , können Sie stattdessen verwenden

results = qp.execute(['Bell'], backend='ibmqx4', shots=1024)

— James Wootton
quelle

4

Das einfachste Quantenprogramm, das ich mir vorstellen kann, ist ein (1-Bit-) Zufallszahlengenerator. Als Quantenschaltung sieht es so aus:

Sie bereiten zunächst ein Qubit im Staat vor $|0 \rangle$ Wenden Sie dann ein Hadamard-Tor an, um die Überlagerung zu erzeugen $\frac{\sqrt{2}}{2} ( \left| 0 \right> + \left| 1 \right> )$ die Sie dann in der rechnerischen Basis messen. Das Messergebnis ist $|0\rangle$ oder $|1\rangle$ jeweils mit einer Wahrscheinlichkeit von 50%.

— Pyramiden
quelle