Hola, Pulse

Aquí aprenderá a construir un par de campanas simple directamente con pulsos y a ejecutar este programa de pulsos en el Rigetti dispositivo. Un par Bell es un circuito de dos cúbits que consiste en una puerta de Hadamard en el primer qubit seguida de una cnot puerta entre el primer y el segundo qubit. La creación de estados entrelazados con pulsos requiere mecanismos específicos que dependen del tipo de hardware y de la arquitectura del dispositivo. No utilizaremos un mecanismo nativo para crear la cnot puerta. En su lugar, utilizaremos formas de onda y marcos específicos que habiliten la cz puerta de forma nativa. En este ejemplo, crearemos una puerta de Hadamard utilizando las puertas nativas de un solo qubit rx rz y expresaremos la puerta mediante pulsos. cz

Primero, importemos las bibliotecas necesarias. Además de la Circuit clase, ahora también tendrás que PulseSequence importarla.

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

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

A continuación, cree una instancia de un nuevo dispositivo Braket con el nombre de recurso de Amazon (ARN) del dispositivo. Rigetti Aspen-M-3 Consulta la página Dispositivos de la consola Amazon Braket para ver el diseño del Rigetti Aspen-M-3 dispositivo.

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")

Como la compuerta Hadamard no es una compuerta nativa del Rigetti dispositivo, no se puede utilizar en combinación con pulsos. Por lo tanto, es necesario descomponerla en una secuencia de puertas y compuertas nativas. rx rz

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

Para la cz compuerta, utilizaremos una forma de onda arbitraria con parámetros (amplitud, tiempo de subida/bajada y duración) predeterminados por el proveedor del hardware durante una etapa de calibración. Esta forma de onda se aplicará a. q10_q113_cz_frame Para obtener una versión más reciente de la forma de onda arbitraria utilizada aquí, consulte QCS, en el sitio web. Rigetti Es posible que deba crear una cuenta de 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')

Esto debería devolver:

CZ pulse duration: 124 ns

Ahora podemos construir la cz puerta usando la forma de onda que acabamos de definir. Recuerde que la cz puerta consiste en un cambio de fase del cúbit objetivo si el cúbit de control está en ese estado. |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 forma de onda se reproduce en un fotograma que está asociado a un puerto de flujo rápido. Su función es cambiar la frecuencia del cúbit para activar una interacción qubit-qubit. Para obtener más información, consulte Funciones de los marcos y los puertos. A medida que varía la frecuencia, los fotogramas de los qubits giran a velocidades diferentes a las de los rf fotogramas de un solo qubit que se mantienen intactos: estos últimos se desfasan. Estos cambios de fase se calibraron previamente mediante Ramsey secuencias y se proporcionan aquí como información codificada de principio a fin (período completo). phase_shift_a phase_shift_b Corregimos esta separación de fases utilizando shift_phase las instrucciones de los marcos. rf Tenga en cuenta que esta secuencia solo funcionará en programas en los que no haya ningún XY fotograma relacionado con el qubit a y b se utilice, ya que no compensamos el cambio de fase que se produce en estos fotogramas. Este es el caso de este programa de un solo par de Bell, que utiliza únicamente cz fotogramas rf y. Para obtener más información, consulte Caldwell et al. .

Ahora estamos listos para crear un par de campanas con pulsos.

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    |

Vamos a ejecutar este par de campanas en el Rigetti dispositivo. Ten en cuenta que ejecutar este bloque de código tendrá un coste. Para obtener más información sobre estos costes, consulta la página de precios Braket de Amazon. Te recomendamos que pruebes tus circuitos con una pequeña cantidad de disparos para asegurarte de que funcionan en el dispositivo antes de aumentar el número de disparos.

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

counts = task.result().measurement_counts

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