À quoi ressemblerait un programme quantique très simple?

15

Après lecture de la " première puce photonique quantique programmable ". Je me demandais exactement à quoi ressemblerait un logiciel pour un ordinateur qui utilise l'intrication quantique.

Existe-t-il un exemple de code pour une programmation quantique spécifique? Comme un pseudocode ou un langage de haut niveau? Plus précisément, quel est le programme le plus court pouvant être utilisé pour créer un état Bell partir d'un état initialisées àutilisantfois une simulation etun des IBMQuantum Experienceprocesseurs, comme leibmqx4?

| ψ ⟩ = \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>$

Faire le saut conceptuel de la programmation traditionnelle à l'intrication n'est pas si simple.

Je l' ai trouvé de C de libquantum aussi.

simulation ibm-q-experience programming

— DIDIx13
source

12

En supposant que vous envisagez un ordinateur quantique basé sur une porte, le moyen le plus simple de produire un état enchevêtré est de produire l'un des états de Bell. Le circuit suivant montre l'état de Bell . $\left| \Phi^+ \right>$

$\left| \psi_0 \right>$ $\left| \psi_1 \right>$ $\left| \psi_2 \right>$

$\left| \psi_0 \right>$

| ψ_{0} ⟩ = | 00 ⟩

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

$\left| \psi_1 \right>$

Le Hadamard-Gate s'applique sur le premier qubit qui se traduit par ce qui suit:

| ψ_{1} ⟩ = (H \otimes je) | 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>$

Maintenant, une porte CNOT est appliquée et retourne le deuxième qubit mais uniquement là où le premier a la valeur 1. Le résultat est

| ψ_{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 )$

Ce dernier état $\left| \psi_2 \right>$ est un état enchevêtré et généralement le moyen le plus naturel de faire face à une telle situation. Les états de Bell se produisent dans de nombreux algorithmes quantiques intéressants tels que le codage super dense ou la téléportation.

Bien que l'approche ci-dessus puisse ne pas vous sembler une programmation au sens habituel, l'application de portes à des états est essentiellement la façon dont la programmation d'un ordinateur quantique basé sur une porte fonctionne. Il existe des couches d'abstraction qui vous permettent d'effectuer une programmation de haut niveau mais de traduire les commandes en application de portes. L' interface IBM Quantum Experience fournit de telles fonctionnalités.

Dans une langue comme Q # de Microsoft, l'exemple ci-dessus pourrait ressembler à ceci:

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]);
         }
     }
}

Une version plus détaillée (y compris la mesure) peut être trouvée ici: Microsoft: Writing a Quantum Program .

— dtell
source

14

Une façon d'écrire des programmes quantiques est avec QISKit. Cela peut être utilisé pour exécuter les programmes sur les périphériques IBM. Le site Web QISKit suggère l'extrait de code suivant pour vous aider à démarrer, qui est un circuit intriqué comme vous le souhaitez. C'est aussi le même processus que dans la réponse par datell. Je vais le commenter ligne par ligne.

# 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'))

Notez que la commande «exécuter» ici spécifie uniquement le programme à exécuter. Tous les autres paramètres, tels que l'appareil que vous souhaitez utiliser, le nombre de fois que vous souhaitez le répéter pour obtenir des statistiques, etc. sont définis sur leurs valeurs par défaut. Pour exécuter sur ibmqx4 pour 1024 plans, vous pouvez utiliser à la place

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

— James Wootton
source

4

Le programme quantique le plus simple auquel je puisse penser est un véritable générateur de nombres aléatoires (1 bit). En tant que circuit quantique, cela ressemble à ceci:

Vous préparez d'abord un qubit dans l'état $|0 \rangle$ , puis appliquez une porte Hadamard pour produire la superposition $\frac{\sqrt{2}}{2} ( \left| 0 \right> + \left| 1 \right> )$ que vous mesurez ensuite dans la base de calcul. Le résultat de la mesure est $|0\rangle$ ou $|1\rangle$ , chacun avec une probabilité de 50%.

— pyramides
source