As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Trabalhando com o Hello Pulse
Nesta seção, você aprenderá a caracterizar e a construir uma única porta de qubit usando a pulsação em um dispositivo Rigetti. A aplicação de um campo eletromagnético a um qubit leva à oscilação Rabi, alternando os qubits entre seu estado 0 e 1 estado. Com o comprimento e a fase calibrados do pulso, a oscilação Rabi pode calcular portas de um único qubit. Aqui, determinaremos o comprimento de pulso ideal para medir um pi/2 pulso, um bloco elementar usado para criar sequências de pulso mais complexas.
Primeiro, para criar uma sequência de pulsos, importe a classe `PulseSequence`.
```
from braket.aws import AwsDevice
from braket.circuits import FreeParameter
from braket.devices import Devices
from braket.pulse import PulseSequence, GaussianWaveform
import numpy as np
```
Em seguida, instancie um novo dispositivo Braket usando o Amazon Resource Name (ARN) da QPU. O bloco de código a seguir usa Rigetti Ankaa-3.
```
device = AwsDevice(Devices.Rigetti.Ankaa3)
```
A sequência de pulsos a seguir inclui dois componentes: reproduzir uma forma de onda e medir um qubit. A sequência de pulsos geralmente pode ser aplicada aos quadros. Com algumas exceções, como barreira e atraso, que podem ser aplicados aos qubits. Antes de construir a sequência de pulsos, você deve recuperar os quadros disponíveis. A estrutura de acionamento é usada para aplicar o pulso para a oscilação Rabi e a estrutura de leitura é para medir o estado do qubit. Este exemplo usa os quadros do qubit 25.
```
drive_frame = device.frames["Transmon_25_charge_tx"]
readout_frame = device.frames["Transmon_25_readout_rx"]
```
Agora, crie a forma de onda que será reproduzida na estrutura da unidade. O objetivo é caracterizar o comportamento dos qubits para diferentes comprimentos de pulso. Você reproduzirá uma forma de onda com comprimentos diferentes a cada vez. Em vez de instanciar uma nova forma de onda a cada vez, use a Braket-supported `FreeParameter` sequência in pulse. Você pode criar a forma de onda e a sequência de pulso uma vez com parâmetros livres e, em seguida, executar a mesma sequência de pulso com valores de entrada diferentes.
```
waveform = GaussianWaveform(FreeParameter("length"), FreeParameter("length") * 0.25, 0.2, False)
```
Finalmente, coloque-os juntos como uma sequência de pulsos. Na sequência de pulsos, `play` reproduz a forma de onda especificada na estrutura da unidade e `capture_v0` mede o estado a partir da estrutura de leitura.
```
pulse_sequence = (
PulseSequence()
.play(drive_frame, waveform)
.capture_v0(readout_frame)
)
```
Digitalize uma faixa de comprimento de pulso e envie-os para a QPU. Antes de executar as sequências de pulso em uma QPU, vincule o valor dos parâmetros livres.
```
start_length = 12e-9
end_length = 2e-7
lengths = np.arange(start_length, end_length, 12e-9)
N_shots = 100
tasks = [
device.run(pulse_sequence(length=length), shots=N_shots)
for length in lengths
]
probability_of_zero = [
task.result().measurement_counts['0']/N_shots
for task in tasks
]
```
As estatísticas da medição do qubit exibem a dinâmica oscilatória do qubit que oscila entre o estado 0 e o estado 1. A partir dos dados de medição, você pode extrair a frequência Rabi e ajustar o comprimento do pulso para implementar uma porta específica de 1 qubit. Por exemplo, a partir dos dados na figura abaixo, a periodicidade é de cerca de 154 ns. Portanto, uma porta pi/2 de rotação corresponderia à sequência de pulso com comprimento = 38,5 ns.
## Hello Pulse usando OpenPulse
[OpenPulse](https://openqasm.com/language/openpulse.html)é uma linguagem para especificar o controle em nível de pulso de um dispositivo quântico geral e faz parte da especificação OpenQASM 3.0. O Amazon Braket suporta o OpenPulse para programação direta de pulsos usando a representação OpenQASM 3.0.
Braket usa OpenPulse como representação intermediária subjacente para expressar pulsos em instruções nativas. OpenPulse suporta a adição de calibrações de instruções na forma de declarações `defcal` (abreviação de “definir calibração”). Com essas declarações, você pode especificar a implementação de uma instrução gate dentro de uma gramática de controle de nível inferior.
Você pode visualizar o OpenPulse programa de um Braket `PulseSequence` usando o comando a seguir.
```
print(pulse_sequence.to_ir())
```
Você também pode construir um OpenPulse programa diretamente.
```
from braket.ir.openqasm import Program
openpulse_script = """
OPENQASM 3.0;
cal {
bit[1] psb;
waveform my_waveform = gaussian(12.0ns, 3.0ns, 0.2, false);
play(Transmon_25_charge_tx, my_waveform);
psb[0] = capture_v0(Transmon_25_readout_rx);
}
"""
```
Crie um objeto `Program` com seu script. Em seguida, envie o programa para uma QPU.
```
from braket.aws import AwsDevice
from braket.devices import Devices
from braket.ir.openqasm import Program
program = Program(source=openpulse_script)
device = AwsDevice(Devices.Rigetti.Ankaa3)
task = device.run(program, shots=100)
```