Bonjour Pulse

Ici, vous apprendrez à construire une simple paire de cloches directement avec des impulsions et à exécuter ce programme d'impulsions sur l'Rigettiappareil. Une paire Bell est un circuit à deux qubits composé d'une porte de Hadamard sur le premier qubit suivie d'une cnot porte entre le premier et le deuxième qubit. La création d'états intriqués à l'aide d'impulsions nécessite des mécanismes spécifiques qui dépendent du type de matériel et de l'architecture du périphérique. Nous n'utiliserons pas de mécanisme natif pour créer la cnot porte. Nous utiliserons plutôt des formes d'onde et des trames spécifiques qui activeront le cz portail de manière native. Dans cet exemple, nous allons créer une porte de Hadamard en utilisant les portes natives à un seul qubit rx rz et exprimer la porte à l'czaide d'impulsions.

Importons d'abord les bibliothèques nécessaires. En plus de la Circuit classe, vous devez désormais également importer la PulseSequence classe.

from braket.aws import AwsDevice
from braket.pulse import PulseSequence, ArbitraryWaveform, GaussianWaveform

from braket.circuits import Circuit
import braket.circuits.circuit as circuit

Ensuite, instanciez un nouvel appareil Braket à l'aide de l'Amazon Resource Name (ARN) de l'appareil. Rigetti Aspen-M-3 Reportez-vous à la page Appareils sur la console Amazon Braket pour voir la disposition de l'Rigetti Aspen-M-3appareil.

a=10 #specifies the control qubit
b=113 #specifies the target qubit
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Aspen-M-3")

La porte Hadamard n'étant pas une porte native du Rigetti dispositif, elle ne peut pas être utilisée en combinaison avec des impulsions. Vous devez donc le décomposer en une séquence de portes rz natives rx et.

import numpy as np
import matplotlib.pyplot as plt
@circuit.subroutine(register=True)
def rigetti_native_h(q0):
    return (
        Circuit()
        .rz(q0, np.pi)
        .rx(q0, np.pi/2)
        .rz(q0, np.pi/2)
        .rx(q0, -np.pi/2)
    )

Pour le cz portail, nous utiliserons une forme d'onde arbitraire dont les paramètres (amplitude, temps de montée/descente et durée) ont été prédéterminés par le fournisseur du matériel lors d'une phase d'étalonnage. Cette forme d'onde sera appliquée sur leq10_q113_cz_frame. Pour une version plus récente de la forme d'onde arbitraire utilisée ici, voir QCS, sur le Rigetti site Web. Vous devrez peut-être créer un compte QCS.

a_b_cz_wfm = ArbitraryWaveform([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.00017888439538396808, 0.00046751103636033026, 0.0011372942989106456, 0.002577059611929697, 0.005443941944632366, 0.010731922770068104, 0.01976701723583167, 0.03406712171899736, 0.05503285980691202, 0.08350670755829034, 0.11932853352131022, 0.16107456696238298, 0.20614055551722368, 0.2512065440720643, 0.292952577513137, 0.328774403476157, 0.3572482512275353, 0.3782139893154499, 0.3925140937986156, 0.40154918826437913, 0.4068371690898149, 0.4097040514225177, 0.41114381673553674, 0.411813599998087, 0.4121022266390633, 0.4122174383870584, 0.41226003881132406, 0.4122746298554775, 0.4122792591252675, 0.4122806196003006, 0.41228098995582513, 0.41228108334474756, 0.4122811051578895, 0.4122811098772742, 0.4122811108230642, 0.4122811109986316, 0.41228111102881937, 0.41228111103362725, 0.4122811110343365, 0.41228111103443343, 0.4122811110344457, 0.4122811110344471, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.41228111103444737, 0.4122811110344471, 0.4122811110344457, 0.41228111103443343, 0.4122811110343365, 0.41228111103362725, 0.41228111102881937, 0.4122811109986316, 0.4122811108230642, 0.4122811098772742, 0.4122811051578895, 0.41228108334474756, 0.41228098995582513, 0.4122806196003006, 0.4122792591252675, 0.4122746298554775, 0.41226003881132406, 0.4122174383870584, 0.4121022266390633, 0.411813599998087, 0.41114381673553674, 0.4097040514225176, 0.4068371690898149, 0.40154918826437913, 0.3925140937986155, 0.37821398931544986, 0.3572482512275351, 0.32877440347615655, 0.2929525775131368, 0.2512065440720641, 0.20614055551722307, 0.16107456696238268, 0.11932853352131002, 0.08350670755829034, 0.05503285980691184, 0.03406712171899729, 0.01976701723583167, 0.010731922770068058, 0.005443941944632366, 0.002577059611929697, 0.0011372942989106229, 0.00046751103636033026, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
a_b_cz_frame = device.frames[f'q{a}_q{b}_cz_frame']

dt = a_b_cz_frame.port.dt
a_b_cz_wfm_duration = len(a_b_cz_wfm.amplitudes)*dt
print('CZ pulse duration:', a_b_cz_wfm_duration*1e9, 'ns')

Cela devrait renvoyer :

CZ pulse duration: 124 ns

Nous pouvons maintenant construire la cz porte en utilisant la forme d'onde que nous venons de définir. Rappelons que la cz porte consiste en un renversement de phase du qubit cible si le qubit de contrôle est dans cet état. |1>

phase_shift_a=1.1733407221086924
phase_shift_b=6.269846678712192

a_rf_frame = device.frames[f'q{a}_rf_frame']
b_rf_frame = device.frames[f'q{b}_rf_frame']

frames = [a_rf_frame, b_rf_frame, a_b_cz_frame]

cz_pulse_sequence = (
    PulseSequence()
    .barrier(frames)
    .play(a_b_cz_frame, a_b_cz_wfm)
    .delay(a_rf_frame, a_b_cz_wfm_duration)
    .shift_phase(a_rf_frame, phase_shift_a)
    .delay(b_rf_frame, a_b_cz_wfm_duration)
    .shift_phase(b_rf_frame, phase_shift_b)
    .barrier(frames)
)

La a_b_cz_wfm forme d'onde est lue sur une image associée à un port de flux rapide. Son rôle est de décaler la fréquence qubit pour activer une interaction qubit-qubit. Pour plus d'informations, consultez la section Rôles des cadres et des ports. À mesure que la fréquence varie, les images à qubit pivotent à des vitesses différentes de celles des rf images à un seul qubit qui restent intactes : ces dernières sont déphasées. Ces changements de phase ont été préalablement étalonnés par le biais de Ramsey séquences et sont fournis ici sous forme d'informations codées en dur via phase_shift_a et phase_shift_b (période complète). Nous corrigeons ce déphasage en utilisant des shift_phase instructions sur rf les cadres. Notez que cette séquence ne fonctionnera que dans les programmes où aucune XY trame n'best associée au qubit a car nous ne compensons pas le décalage de phase qui se produit sur ces images. C'est le cas de ce programme à paire unique de Bell, qui utilise uniquement des cz cadres rf et des cadres. Pour plus d'informations, voir Caldwell et al. .

Nous sommes maintenant prêts à créer une paire de cloches avec des pulsations.

bell_circuit_pulse = (
    Circuit()
    .rigetti_native_h(a)
    .rigetti_native_h(b)
    .pulse_gate([a, b], cz_pulse_sequence)
    .rigetti_native_h(b)
)
print(bell_circuit_pulse)

T  : |   0    |   1    |   2    |    3    |4 |   5    |   6    |   7    |    8    |

q5 : -Rz(3.14)-Rx(1.57)-Rz(1.57)-Rx(-1.57)-PG--------------------------------------
                                           |
q6 : -Rz(3.14)-Rx(1.57)-Rz(1.57)-Rx(-1.57)-PG-Rz(3.14)-Rx(1.57)-Rz(1.57)-Rx(-1.57)-

T  : |   0    |   1    |   2    |    3    |4 |   5    |   6    |   7    |    8    |

Faisons fonctionner cette paire Bell sur l'Rigettiappareil. Notez que l'exécution de ce bloc de code entraîne des frais. Pour plus d'informations sur ces coûts, consultez la page de tarification d'Amazon Braket. Nous vous recommandons de tester vos circuits à l'aide d'un petit nombre de tirs pour vous assurer qu'ils peuvent fonctionner sur l'appareil avant d'augmenter le nombre de tirs.

task = device.run(bell_pair_pulses, shots=100)

counts = task.result().measurement_counts

plt.bar(sorted(counts), [counts[k] for k in sorted(counts)])