Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Membangun tugas kuantum Anda dengan Amazon Braket
Build

Braket menyediakan lingkungan notebook Jupyter yang dikelola sepenuhnya yang membuatnya mudah untuk memulai. Notebook Braket sudah diinstal sebelumnya dengan algoritma sampel, sumber daya, dan alat pengembang, termasuk Amazon Braket SDK. Dengan Amazon Braket SDK, Anda dapat membangun algoritma kuantum dan kemudian menguji dan menjalankannya pada komputer kuantum dan simulator yang berbeda dengan mengubah satu baris kode.

**Topics**
+ [

# Membangun sirkuit pertama Anda
](braket-get-started-run-circuit.md)
+ [

# Mendapatkan saran ahli
](braket-expert-advice.md)
+ [

# Jalankan sirkuit Anda dengan OpenQASM 3.0
](braket-openqasm.md)
+ [

# Jelajahi Kemampuan Eksperimental
](braket-experimental-capabilities.md)
+ [

# Kontrol pulsa pada Amazon Braket
](braket-pulse-control.md)
+ [

# Simulasi Hamiltonian Analog
](braket-analog-hamiltonian-simulation.md)
+ [

# Bekerja dengan AWS Boto3
](braket-using-boto3.md)

# Membangun sirkuit pertama Anda


Setelah instans notebook Anda diluncurkan, buka instans dengan antarmuka Jupyter standar dengan memilih notebook yang baru saja Anda buat.

![\[Antarmuka notebook yang menunjukkan instance notebook yang ada bernama amazon-braket-test dengan status InService dan URL-nya.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/console-page.png)


Instans notebook Amazon Braket diinstal sebelumnya dengan SDK Amazon Braket dan semua dependensinya. Mulailah dengan membuat notebook baru dengan Kernel `conda_braket`.

![\[Antarmuka peluncur untuk Notebook, Konsol, dan alat lainnya seperti Terminal, File Teks, File Markdown, File Python, dengan lingkungan Python conda_braket yang disorot.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/jupyter-open.png)


Anda bisa mulai dengan yang sederhana seperti “Halo, dunia\$1” contoh. Pertama, bangun sirkuit yang mempersiapkan keadaan Bell, dan kemudian jalankan sirkuit pada perangkat yang berbeda untuk mendapatkan hasil.

Mulailah dengan mengimpor Begin dengan mengimpor modul SDK Amazon Braket dan mendefinisikan modul SDK BRAKETlong sederhana dan mendefinisikan sirkuit Bell State dasar.

```
import boto3
from braket.aws import AwsDevice
from braket.devices import LocalSimulator
from braket.circuits import Circuit

# Create the circuit
bell = Circuit().h(0).cnot(0, 1)
```

Anda dapat memvisualisasikan sirkuit dengan perintah ini:

```
print(bell)
```

```
T  : │  0  │  1  │
      ┌───┐       
q0 : ─┤ H ├───●───
      └───┘   │   
            ┌─┴─┐ 
q1 : ───────┤ X ├─
            └───┘ 
T  : │  0  │  1  │
```

 **Jalankan sirkuit Anda di simulator lokal** 

Selanjutnya, pilih perangkat kuantum untuk menjalankan sirkuit. SDK Amazon Braket dilengkapi dengan simulator lokal untuk prototyping dan pengujian cepat. Kami merekomendasikan menggunakan simulator lokal untuk sirkuit yang lebih kecil, yang bisa mencapai 25 qubits (tergantung pada perangkat keras lokal Anda).

Untuk membuat instance simulator lokal:

```
# Instantiate the local simulator
local_sim = LocalSimulator()
```

dan menjalankan sirkuit:

```
# Run the circuit
result = local_sim.run(bell, shots=1000).result()
counts = result.measurement_counts
print(counts)
```

Anda seharusnya melihat hasil seperti ini:

```
Counter({'11': 503, '00': 497})
```

Keadaan Lonceng spesifik yang telah Anda siapkan adalah superposisi yang sama dari \$100⟩ dan \$111⟩, dan distribusi 00 dan 11 yang hampir sama (hingga shot kebisingan) sebagai hasil pengukuran, seperti yang diharapkan.

 **Jalankan sirkuit Anda pada simulator sesuai permintaan** 

Amazon Braket juga menyediakan akses ke simulator berkinerja tinggi sesuai permintaanSV1, untuk menjalankan sirkuit yang lebih besar. SV1adalah simulator vektor negara sesuai permintaan yang memungkinkan simulasi sirkuit kuantum hingga 34. qubits Anda dapat menemukan informasi selengkapnya SV1 di bagian [Perangkat yang Didukung](braket-devices.md) dan di AWS konsol. Saat menjalankan tugas kuantum pada SV1 (dan di TN1 atau QPU apa pun), hasil tugas kuantum Anda disimpan dalam bucket S3 di akun Anda. Jika Anda tidak menentukan bucket, Braket SDK akan membuat bucket default `amazon-braket-{region}-{accountID}` untuk Anda. Untuk mempelajari lebih lanjut, lihat [Mengelola akses ke Amazon Braket](braket-manage-access.md).

**catatan**  
Isi nama bucket sebenarnya yang ada di mana contoh berikut menunjukkan `amazon-braket-s3-demo-bucket` sebagai nama bucket Anda. Nama bucket untuk Amazon Braket selalu dimulai dengan `amazon-braket-` diikuti dengan karakter pengidentifikasi lain yang Anda tambahkan. Jika Anda memerlukan informasi tentang cara menyiapkan bucket S3, lihat [Memulai Amazon](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html) S3.

```
# Get the account ID
aws_account_id = boto3.client("sts").get_caller_identity()["Account"]

# The name of the bucket
my_bucket = "amazon-braket-s3-demo-bucket"

# The name of the folder in the bucket
my_prefix = "simulation-output"
s3_folder = (my_bucket, my_prefix)
```

Untuk menjalankan sirkuitSV1, Anda harus memberikan lokasi bucket S3 yang sebelumnya Anda pilih sebagai argumen posisi dalam panggilan. `.run()`

```
# Choose the cloud-based on-demand simulator to run your circuit
device = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")

# Run the circuit
task = device.run(bell, s3_folder, shots=100)

# Display the results
print(task.result().measurement_counts)
```

Konsol Amazon Braket memberikan informasi lebih lanjut tentang tugas kuantum Anda. Arahkan ke tab **Quantum Tasks** di konsol dan tugas kuantum Anda harus berada di bagian atas daftar. Atau, Anda dapat mencari tugas kuantum Anda menggunakan ID tugas kuantum unik atau kriteria lainnya.

**catatan**  
Setelah 90 hari, Amazon Braket secara otomatis menghapus semua tugas kuantum IDs dan metadata lain yang terkait dengan tugas kuantum Anda. Untuk informasi lebih lanjut, lihat [Retensi data](https://docs.aws.amazon.com/braket/latest/developerguide/security.html#braket-data-retention).

 **Berjalan di QPU** 

Dengan Amazon Braket, Anda dapat menjalankan contoh sirkuit kuantum sebelumnya pada komputer kuantum fisik hanya dengan mengubah satu baris kode. Amazon Braket menyediakan akses ke berbagai perangkat Quantum Processing Unit (QPU). Anda dapat menemukan informasi tentang berbagai perangkat dan jendela ketersediaan di bagian [Perangkat yang Didukung](braket-devices.md), dan di AWS konsol di bawah tab **Perangkat**. Contoh berikut menunjukkan cara membuat instance IQM perangkat.

```
# Choose the IQM hardware to run your circuit
device = AwsDevice("arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet")
```

Atau pilih IonQ perangkat dengan kode ini:

```
# Choose the Ionq device to run your circuit
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Aria-1")
```

Setelah memilih perangkat dan sebelum menjalankan beban kerja, Anda dapat menanyakan kedalaman antrian perangkat dengan kode berikut untuk menentukan jumlah tugas kuantum atau pekerjaan hibrida. Selain itu, pelanggan dapat melihat kedalaman antrian khusus perangkat di halaman Perangkat. Amazon Braket Management Console 

```
# Print your queue depth
print(device.queue_depth().quantum_tasks)
# Returns the number of quantum tasks queued on the device
# {<QueueType.NORMAL: 'Normal'>: '0', <QueueType.PRIORITY: 'Priority'>: '0'}

print(device.queue_depth().jobs)
# Returns the number of hybrid jobs queued on the device
# '2'
```

Saat Anda menjalankan tugas, SDK Amazon Braket melakukan polling untuk hasil (dengan batas waktu default 5 hari). Anda dapat mengubah default ini dengan memodifikasi `poll_timeout_seconds` parameter dalam `.run()` perintah seperti yang ditunjukkan pada contoh berikut. Perlu diingat bahwa jika batas waktu polling Anda terlalu pendek, hasil mungkin tidak dikembalikan dalam waktu polling, seperti ketika QPU tidak tersedia dan kesalahan batas waktu lokal dikembalikan. Anda dapat merestart pemungutan suara dengan memanggil fungsi `task.result()`.

```
# Define quantum task with 1 day polling timeout
task = device.run(bell, s3_folder, poll_timeout_seconds=24*60*60)
print(task.result().measurement_counts)
```

Selain itu, setelah mengirimkan tugas kuantum atau pekerjaan hibrida Anda, Anda dapat memanggil `queue_position()` fungsi untuk memeriksa posisi antrian Anda.

```
print(task.queue_position().queue_position)
# Return the number of quantum tasks queued ahead of you
# '2'
```

# Membangun algoritma kuantum pertama Anda


Pustaka algoritma Amazon Braket adalah katalog algoritma kuantum pra-bangun yang ditulis dengan Python. Jalankan algoritma ini apa adanya, atau gunakan sebagai titik awal untuk membangun algoritma yang lebih kompleks. Anda dapat mengakses pustaka algoritma dari konsol Braket. Untuk informasi selengkapnya, lihat pustaka [algoritma Braket Github](https://github.com/aws-samples/amazon-braket-algorithm-library).

![\[Halaman pustaka Algoritma Amazon Braket yang menampilkan daftar algoritma kuantum pra-bangun seperti Berstein Vazirani, Deutsch-Jozsa, algoritma Grover, dan Algoritma Pengoptimalan Perkiraan Kuantum dengan deskripsi singkat.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/AlgorithmLibrary.png)


Konsol Braket memberikan deskripsi dari setiap algoritma yang tersedia di perpustakaan algoritma. Pilih GitHub tautan untuk melihat detail setiap algoritme, atau pilih **Buka buku catatan** untuk membuka atau membuat buku catatan yang berisi semua algoritme yang tersedia. Jika Anda memilih opsi notebook, Anda kemudian dapat menemukan pustaka algoritma Braket di folder root notebook Anda.

# Membangun sirkuit di SDK


Bagian ini memberikan contoh mendefinisikan sirkuit, melihat gerbang yang tersedia, memperluas sirkuit, dan melihat gerbang yang didukung setiap perangkat. Ini juga berisi instruksi tentang cara mengalokasikan secara manualqubits, menginstruksikan kompiler untuk menjalankan sirkuit Anda persis seperti yang ditentukan, dan membangun sirkuit bising dengan simulator kebisingan.

Anda juga dapat bekerja pada tingkat pulsa di Braket untuk berbagai gerbang dengan tertentu QPUs. Untuk informasi selengkapnya, lihat [Kontrol Pulsa di Amazon Braket](braket-pulse-control.md).

**Topics**
+ [

## Gerbang dan sirkuit
](#braket-gates)
+ [

## Set program
](#braket-program-set)
+ [

## Pengukuran sebagian
](#braket-partial-measurement)
+ [

## Alokasi manual qubit
](#manual-qubit-allocation)
+ [

## Kompilasi kata demi kata
](#verbatim-compilation)
+ [

## Simulasi kebisingan
](#noise-simulation)

## Gerbang dan sirkuit


Gerbang dan sirkuit kuantum didefinisikan di [https://github.com/aws/amazon-braket-sdk-python/blob/main/src/braket/circuits/circuit.py](https://github.com/aws/amazon-braket-sdk-python/blob/main/src/braket/circuits/circuit.py)kelas Amazon Braket Python SDK. Dari SDK, Anda dapat memberi contoh objek sirkuit baru dengan memanggil `Circuit()`.

 **Contoh: Tentukan sirkuit** 

Contoh dimulai dengan mendefinisikan rangkaian sampel empat qubits (berlabel`q0`,,`q1`, dan`q3`) yang terdiri dari gerbang `q2` Hadamard qubit tunggal standar dan gerbang CNOT dua-qubit. Anda dapat memvisualisasikan rangkaian ini dengan memanggil `print` fungsi seperti yang ditunjukkan contoh berikut.

```
# Import the circuit module
from braket.circuits import Circuit

# Define circuit with 4 qubits
my_circuit = Circuit().h(range(4)).cnot(control=0, target=2).cnot(control=1, target=3)
print(my_circuit)
```

```
T  : │  0  │     1     │
      ┌───┐             
q0 : ─┤ H ├───●─────────
      └───┘   │         
      ┌───┐   │         
q1 : ─┤ H ├───┼─────●───
      └───┘   │     │   
      ┌───┐ ┌─┴─┐   │   
q2 : ─┤ H ├─┤ X ├───┼───
      └───┘ └───┘   │   
      ┌───┐       ┌─┴─┐ 
q3 : ─┤ H ├───────┤ X ├─
      └───┘       └───┘ 
T  : │  0  │     1     │
```

 **Contoh: Tentukan sirkuit berparameter** 

Dalam contoh ini, kami mendefinisikan sirkuit dengan gerbang yang bergantung pada parameter bebas. Kita dapat menentukan nilai parameter ini untuk membuat sirkuit baru, atau, saat mengirimkan sirkuit, untuk dijalankan sebagai tugas kuantum pada perangkat tertentu.

```
from braket.circuits import Circuit, FreeParameter

# Define a FreeParameter to represent the angle of a gate
alpha = FreeParameter("alpha")

# Define a circuit with three qubits
my_circuit = Circuit().h(range(3)).cnot(control=0, target=2).rx(0, alpha).rx(1, alpha)
print(my_circuit)
```

Anda dapat membuat sirkuit baru yang tidak berparameter dari rangkaian parametris dengan memasok satu `float` (yang merupakan nilai yang akan diambil semua parameter bebas) atau argumen kata kunci yang menentukan nilai setiap parameter ke rangkaian sebagai berikut.

```
my_fixed_circuit = my_circuit(1.2)
my_fixed_circuit = my_circuit(alpha=1.2)
print(my_fixed_circuit)
```

Perhatikan bahwa tidak `my_circuit` dimodifikasi, sehingga Anda dapat menggunakannya untuk membuat instance banyak sirkuit baru dengan nilai parameter tetap.

 **Contoh: Memodifikasi gerbang di sirkuit** 

Contoh berikut mendefinisikan sirkuit dengan gerbang yang menggunakan kontrol dan pengubah daya. Anda dapat menggunakan modifikasi ini untuk membuat gerbang baru, seperti `Ry` gerbang yang dikendalikan.

```
from braket.circuits import Circuit

# Create a bell circuit with a controlled x gate
my_circuit = Circuit().h(0).x(control=0, target=1)

# Add a multi-controlled Ry gate of angle .13
my_circuit.ry(angle=.13, target=2, control=(0, 1))

# Add a 1/5 root of X gate
my_circuit.x(0, power=1/5)

print(my_circuit)
```

Pengubah gerbang hanya didukung pada simulator lokal.

 **Contoh: Lihat semua gerbang yang tersedia** 

Contoh berikut menunjukkan bagaimana melihat semua gerbang yang tersedia di Amazon Braket.

```
from braket.circuits import Gate
# Print all available gates in Amazon Braket
gate_set = [attr for attr in dir(Gate) if attr[0].isupper()]
print(gate_set)
```

Output dari kode ini mencantumkan semua gerbang.

```
['CCNot', 'CNot', 'CPhaseShift', 'CPhaseShift00', 'CPhaseShift01', 'CPhaseShift10', 'CSwap', 'CV', 'CY', 'CZ', 'ECR', 'GPhase', 'GPi', 'GPi2', 'H', 'I', 'ISwap', 'MS', 'PRx', 'PSwap', 'PhaseShift', 'PulseGate', 'Rx', 'Ry', 'Rz', 'S', 'Si', 'Swap', 'T', 'Ti', 'U', 'Unitary', 'V', 'Vi', 'X', 'XX', 'XY', 'Y', 'YY', 'Z', 'ZZ']
```

Setiap gerbang ini dapat ditambahkan ke sirkuit dengan memanggil metode untuk jenis sirkuit. Misalnya, panggil`circ.h(0)`, untuk menambahkan gerbang Hadamard ke yang pertama. qubit

**catatan**  
Gerbang ditambahkan di tempat, dan contoh yang mengikutinya menambahkan semua gerbang yang tercantum dalam contoh sebelumnya ke sirkuit yang sama.

```
circ = Circuit()
# toffoli gate with q0, q1 the control qubits and q2 the target.
circ.ccnot(0, 1, 2)
# cnot gate
circ.cnot(0, 1)
# controlled-phase gate that phases the |11> state, cphaseshift(phi) = diag((1,1,1,exp(1j*phi))), where phi=0.15 in the examples below
circ.cphaseshift(0, 1, 0.15)
# controlled-phase gate that phases the |00> state, cphaseshift00(phi) = diag([exp(1j*phi),1,1,1])
circ.cphaseshift00(0, 1, 0.15)
# controlled-phase gate that phases the |01> state, cphaseshift01(phi) = diag([1,exp(1j*phi),1,1])
circ.cphaseshift01(0, 1, 0.15)
# controlled-phase gate that phases the |10> state, cphaseshift10(phi) = diag([1,1,exp(1j*phi),1])
circ.cphaseshift10(0, 1, 0.15)
# controlled swap gate
circ.cswap(0, 1, 2)
# swap gate
circ.swap(0,1)
# phaseshift(phi)= diag([1,exp(1j*phi)])
circ.phaseshift(0,0.15)
# controlled Y gate
circ.cy(0, 1)
# controlled phase gate
circ.cz(0, 1)
# Echoed cross-resonance gate applied to q0, q1
circ = Circuit().ecr(0,1)
# X rotation with angle 0.15
circ.rx(0, 0.15)
# Y rotation with angle 0.15
circ.ry(0, 0.15)
# Z rotation with angle 0.15
circ.rz(0, 0.15)
# Hadamard gates applied to q0, q1, q2
circ.h(range(3))
# identity gates applied to q0, q1, q2
circ.i([0, 1, 2])
# iswap gate, iswap = [[1,0,0,0],[0,0,1j,0],[0,1j,0,0],[0,0,0,1]]
circ.iswap(0, 1)
# pswap gate, PSWAP(phi) = [[1,0,0,0],[0,0,exp(1j*phi),0],[0,exp(1j*phi),0,0],[0,0,0,1]]
circ.pswap(0, 1, 0.15)
# X gate applied to q1, q2
circ.x([1, 2])
# Y gate applied to q1, q2
circ.y([1, 2])
# Z gate applied to q1, q2
circ.z([1, 2])
# S gate applied to q0, q1, q2
circ.s([0, 1, 2])
# conjugate transpose of S gate applied to q0, q1
circ.si([0, 1])
# T gate applied to q0, q1
circ.t([0, 1])
# conjugate transpose of T gate applied to q0, q1
circ.ti([0, 1])
# square root of not gate applied to q0, q1, q2
circ.v([0, 1, 2])
# conjugate transpose of square root of not gate applied to q0, q1, q2
circ.vi([0, 1, 2])
# exp(-iXX theta/2)
circ.xx(0, 1, 0.15)
# exp(i(XX+YY) theta/4), where theta=0.15 in the examples below
circ.xy(0, 1, 0.15)
# exp(-iYY theta/2)
circ.yy(0, 1, 0.15)
# exp(-iZZ theta/2)
circ.zz(0, 1, 0.15)
# IonQ native gate GPi with angle 0.15 applied to q0
circ.gpi(0, 0.15)
# IonQ native gate GPi2 with angle 0.15 applied to q0
circ.gpi2(0, 0.15)
# IonQ native gate MS with angles 0.15, 0.15, 0.15 applied to q0, q1
circ.ms(0, 1, 0.15, 0.15, 0.15)
```

Terlepas dari gerbang set yang telah ditentukan sebelumnya, Anda juga dapat menerapkan gerbang kesatuan yang didefinisikan sendiri ke sirkuit. Ini bisa berupa gerbang qubit tunggal (seperti yang ditunjukkan pada kode sumber berikut) atau gerbang multi-qubit yang diterapkan pada yang qubits ditentukan oleh parameter. `targets`

```
import numpy as np

# Apply a general unitary
my_unitary = np.array([[0, 1],[1, 0]])
circ.unitary(matrix=my_unitary, targets=[0])
```

 **Contoh: Perluas sirkuit yang ada** 

Anda dapat memperpanjang sirkuit yang ada dengan menambahkan instruksi. An `Instruction` adalah direktif kuantum yang menggambarkan tugas kuantum yang harus dilakukan pada perangkat kuantum. `Instruction`operator menyertakan objek tipe `Gate` saja.

```
# Import the Gate and Instruction modules
from braket.circuits import Gate, Instruction

# Add instructions directly.
circ = Circuit([Instruction(Gate.H(), 4), Instruction(Gate.CNot(), [4, 5])])

# Or with add_instruction/add functions
instr = Instruction(Gate.CNot(), [0, 1])
circ.add_instruction(instr)
circ.add(instr)

# Specify where the circuit is appended
circ.add_instruction(instr, target=[3, 4])
circ.add_instruction(instr, target_mapping={0: 3, 1: 4})

# Print the instructions
print(circ.instructions)
# If there are multiple instructions, you can print them in a for loop
for instr in circ.instructions:
     print(instr)

# Instructions can be copied
new_instr = instr.copy()
# Appoint the instruction to target
new_instr = instr.copy(target=[5, 6])
new_instr = instr.copy(target_mapping={0: 5, 1: 6})
```

 **Contoh: Lihat gerbang yang didukung setiap perangkat** 

Simulator mendukung semua gerbang di SDK Braket, namun perangkat QPU mendukung subset yang lebih kecil. Anda dapat menemukan gerbang perangkat yang didukung di properti perangkat. Berikut ini menunjukkan contoh dengan perangkat ionQ:

```
# Import the device module
from braket.aws import AwsDevice

device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Aria-1")

# Get device name
device_name = device.name
# Show supportedQuantumOperations (supported gates for a device)
device_operations = device.properties.dict()['action']['braket.ir.openqasm.program']['supportedOperations']
print('Quantum Gates supported by {}:\n {}'.format(device_name, device_operations))
```

```
Quantum Gates supported by Aria 1:
 ['x', 'y', 'z', 'h', 's', 'si', 't', 'ti', 'v', 'vi', 'rx', 'ry', 'rz', 'cnot', 'swap', 'xx', 'yy', 'zz']
```

Gerbang yang didukung mungkin perlu dikompilasi ke gerbang asli sebelum mereka dapat berjalan pada perangkat keras kuantum. Saat Anda mengirimkan sirkuit, Amazon Braket melakukan kompilasi ini secara otomatis.

 **Contoh: Secara terprogram mengambil kesetiaan gerbang asli yang didukung oleh perangkat** 

Anda dapat melihat informasi kesetiaan di halaman **Perangkat konsol** Braket. Terkadang sangat membantu untuk mengakses informasi yang sama secara terprogram. Kode berikut menunjukkan cara mengekstrak kesetiaan dua qubit gerbang antara dua gerbang QPU.

```
# Import the device module
from braket.aws import AwsDevice
 
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3") 

# Specify the qubits 
a=10 
b=11
edge_properties_entry = device.properties.standardized.twoQubitProperties['10-11'].twoQubitGateFidelity
gate_name = edge_properties_entry[0].gateName
fidelity = edge_properties_entry[0].fidelity
print(f"Fidelity of the {gate_name} gate between qubits {a} and {b}: {fidelity}")
```

## Set program


Set program secara efisien menjalankan beberapa sirkuit kuantum dalam satu tugas kuantum. Dalam satu tugas itu, Anda dapat mengirimkan hingga 100 sirkuit kuantum atau rangkaian parametrik tunggal dengan hingga 100 set parameter yang berbeda. Operasi ini meminimalkan waktu antara eksekusi sirkuit berikutnya dan mengurangi overhead pemrosesan tugas kuantum. Saat ini, set program didukung di Amazon Braket Local Simulator dan seterusnyaAQT, IQM dan Rigetti perangkat.

**Mendefinisikan a ProgramSet**

Contoh kode pertama berikut menunjukkan bagaimana membangun `ProgramSet` menggunakan sirkuit parameter dan sirkuit tanpa parameter.

```
from braket.aws import AwsDevice
from braket.circuits import Circuit, FreeParameter
from braket.program_sets.circuit_binding import CircuitBinding
from braket.program_sets import ProgramSet

# Initialize the quantum device
device = AwsDevice("arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet")

# Define circuits
circ1 = Circuit().h(0).cnot(0, 1)
circ2 = Circuit().rx(0, 0.785).ry(1, 0.393).cnot(1, 0)
circ3 = Circuit().t(0).t(1).cz(0, 1).s(0).cz(1, 2).s(1).s(2)
parameterize_circuit = Circuit().rx(0, FreeParameter("alpha")).cnot(0, 1).ry(1, FreeParameter("beta"))

# Create circuit bindings with different parameters
circuit_binding = CircuitBinding(
    circuit=parameterize_circuit,
    input_sets={
            'alpha': (0.10, 0.11, 0.22, 0.34, 0.45),
            'beta': (1.01, 1.01, 1.03, 1.04, 1.04),
    })

# Creating the program set
program_set_1 = ProgramSet([
    circ1,
    circ2,
    circ3,
    circuit_binding,
])
```

Set program ini berisi empat program unik:`circ1`,`circ2`,`circ3`, dan`circuit_binding`. `circuit_binding`Program ini berjalan dengan lima binding parameter yang berbeda, menciptakan lima executable. Tiga program bebas parameter lainnya membuat satu executable masing-masing. Ini menghasilkan delapan total executable, seperti yang ditunjukkan pada gambar berikut.

![\[ProgramSet struktur dengan empat sirkuit, di mana c4 menggunakan CircuitBinding untuk memproses lima set input.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/program_set1.png)


Contoh kode kedua berikut menunjukkan bagaimana menggunakan `product()` metode untuk melampirkan set observable yang sama untuk setiap executable dari set program.

```
from braket.circuits.observables import I, X, Y, Z

observables = [Z(0) @ Z(1), X(0) @ X(1), Z(0) @ X(1), X(0) @ Z(1)]

program_set_2 = ProgramSet.product(
    circuits=[circ1, circ2, circuit_binding],
    observables=observables
)
```

Untuk program bebas parameter, setiap observable diukur untuk setiap rangkaian. Untuk program parametrik, setiap observable diukur untuk setiap set input, seperti yang ditunjukkan pada gambar berikut.

![\[ProgramSet.product menunjukkan eksekusi paralel dari tiga sirkuit, dengan c3 menggunakan CircuitBinding untuk memproses lima set input dengan masing-masing lima yang dapat diamati.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/program_set2.png)


Contoh kode ketiga berikut menunjukkan bagaimana menggunakan `zip()` metode untuk memasangkan individu yang dapat diamati dengan set parameter tertentu di. `ProgramSet`

```
program_set_3 = ProgramSet.zip(
    circuits=circuit_binding,
    observables=observables + [Y(0) @ Y(1)]
)
```

![\[ProgramSet.zip dengan CircuitBinding mendemonstrasikan lima eksekusi paralel menggunakan sirkuit bersama dengan individu yang dapat diamati per set input.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/program_set3.png)


Alih-alih`CircuitBinding()`, Anda dapat langsung zip daftar yang dapat diamati dengan daftar sirkuit dan set input. 

```
program_set_4 = ProgramSet.zip(
    circuits=[circ1, circ2, circ3],
    input_sets=[{}, {}, {}],
    observables=observables[:3]
)
```

![\[ProgramSet.zip menunjukkan eksekusi paralel dari tujuh sirkuit dengan set input individu yang sesuai dan yang dapat diamati individu.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/program_set4.png)


Untuk informasi selengkapnya dan contoh tentang set program, lihat [folder Set Program](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/braket_features/program_sets) di amazon-braket-examples Github.

**Memeriksa dan menjalankan program yang ditetapkan pada perangkat**

Hitungan eksekusi set program sama dengan jumlah sirkuit terikat parameter uniknya. Hitung jumlah total sirkuit yang dapat dieksekusi dan tembakan menggunakan contoh kode berikut.

```
# Number of shots per executable
shots = 10
num_executables = program_set_1.total_executables

# Calculate total number of shots across all executables
total_num_shots = shots*num_executables
```

**catatan**  
Dengan set program, Anda membayar satu biaya per tugas dan biaya per tembakan berdasarkan jumlah total tembakan di semua sirkuit dalam satu set program.

Untuk menjalankan set program, gunakan contoh kode berikut.

```
# Run the program set
task = device.run(
   program_set_1, shots=total_num_shots,
)
```

Saat menggunakan Rigetti perangkat, set program Anda mungkin tetap dalam `RUNNING` status sementara tugas sebagian selesai dan sebagian antri. Untuk hasil yang lebih cepat, pertimbangkan untuk mengirimkan program Anda yang ditetapkan sebagai [Job](braket-jobs-first.md) Hybrid.

**Menganalisis hasil**

Jalankan kode berikut untuk menganalisis dan mengukur hasil executable dalam file. `ProgramSet`

```
# Get the results from a program set 
result = task.result()

# Get the first executbable
first_program = result[0] 
first_executable = first_program[0]

# Inspect the results of the first executable
measurements_from_first_executable = first_executable.measurements
print(measurements_from_first_executable)
```

## Pengukuran sebagian


Alih-alih mengukur semua qubit dalam rangkaian kuantum, gunakan pengukuran paral untuk mengukur qubit individu atau subset qubit. 

**catatan**  
Fitur tambahan seperti pengukuran sirkuit tengah dan operasi feed-forward tersedia sebagai Kemampuan Eksperimental, lihat [Akses ke sirkuit dinamis pada](braket-experimental-capabilities.md#braket-access-dynamic-circuits) perangkat IQM.

**Contoh: Ukur subset qubit**

Contoh kode berikut menunjukkan pengukuran sebagian dengan mengukur hanya qubit 0 dalam rangkaian keadaan Bell.

```
from braket.devices import LocalSimulator
from braket.circuits import Circuit

# Use the local state vector simulator
device = LocalSimulator()

# Define an example bell circuit and measure qubit 0
circuit = Circuit().h(0).cnot(0, 1).measure(0)

# Run the circuit
task = device.run(circuit, shots=10)

# Get the results
result = task.result()

# Print the circuit and measured qubits
print(circuit)
print()
print("Measured qubits: ", result.measured_qubits)
```

## Alokasi manual qubit


Ketika Anda menjalankan sirkuit kuantum pada komputer kuantum dariRigetti, Anda dapat secara opsional menggunakan qubit alokasi manual untuk mengontrol yang qubits digunakan untuk algoritma Anda. [Konsol Amazon Braket](https://console.aws.amazon.com/braket/home) dan SDK [Amazon Braket membantu Anda memeriksa data kalibrasi](https://github.com/aws/amazon-braket-sdk-python) terbaru dari perangkat unit pemrosesan kuantum (QPU) yang Anda pilih, sehingga Anda dapat memilih yang terbaik untuk eksperimen Anda. qubits

qubitAlokasi manual memungkinkan Anda untuk menjalankan sirkuit dengan akurasi yang lebih besar dan untuk menyelidiki qubit properti individu. Peneliti dan pengguna tingkat lanjut mengoptimalkan desain sirkuit mereka berdasarkan data kalibrasi perangkat terbaru dan dapat memperoleh hasil yang lebih akurat.

Contoh berikut menunjukkan bagaimana qubits mengalokasikan secara eksplisit.

```
# Import the device module
from braket.aws import AwsDevice

device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
circ = Circuit().h(0).cnot(0, 7)  # Indices of actual qubits in the QPU

# Set up S3 bucket (where results are stored)
my_bucket = "amazon-braket-s3-demo-bucket" # The name of the bucket
my_prefix = "your-folder-name" # The name of the folder in the bucket
s3_location = (my_bucket, my_prefix)

my_task = device.run(circ, s3_location, shots=100, disable_qubit_rewiring=True)
```

Untuk informasi selengkapnya, lihat [contoh Amazon Braket di GitHub](https://github.com/aws/amazon-braket-examples), atau lebih khusus lagi, buku catatan ini: [Mengalokasikan Qubit di Perangkat QPU](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Allocating_Qubits_on_QPU_Devices.ipynb).

## Kompilasi kata demi kata


Saat Anda menjalankan sirkuit kuantum pada komputer kuantum berbasis gerbang, Anda dapat mengarahkan kompiler untuk menjalankan sirkuit Anda persis seperti yang ditentukan tanpa modifikasi apa pun. Dengan menggunakan kompilasi kata demi kata, Anda dapat menentukan bahwa seluruh rangkaian dipertahankan tepat seperti yang ditentukan atau hanya bagian tertentu saja yang dipertahankan (hanya didukung olehRigetti). Saat mengembangkan algoritme untuk pembandingan perangkat keras atau protokol mitigasi kesalahan, Anda perlu memiliki opsi untuk menentukan dengan tepat gerbang dan tata letak sirkuit yang berjalan pada perangkat keras. Kompilasi verbatim memberi Anda kontrol langsung atas proses kompilasi dengan mematikan langkah-langkah pengoptimalan tertentu, sehingga memastikan bahwa sirkuit Anda berjalan persis seperti yang dirancang.

Kompilasi verbatim didukung padaAQT,, IonQIQM, dan Rigetti perangkat dan membutuhkan penggunaan gerbang asli. Saat menggunakan kompilasi kata demi kata, disarankan untuk memeriksa topologi perangkat untuk memastikan bahwa gerbang dipanggil terhubung qubits dan bahwa sirkuit menggunakan gerbang asli yang didukung pada perangkat keras. Contoh berikut menunjukkan cara mengakses daftar gerbang asli yang didukung oleh perangkat secara terprogram.

```
device.properties.paradigm.nativeGateSet
```

UntukRigetti, qubit rewiring harus dimatikan dengan pengaturan `disableQubitRewiring=True` untuk digunakan dengan kompilasi kata demi kata. Jika `disableQubitRewiring=False` disetel saat menggunakan kotak kata demi kata dalam kompilasi, rangkaian kuantum gagal validasi dan tidak berjalan.

Jika kompilasi kata demi kata diaktifkan untuk sirkuit dan dijalankan pada QPU yang tidak mendukungnya, kesalahan dihasilkan yang menunjukkan bahwa operasi yang tidak didukung telah menyebabkan tugas gagal. Karena semakin banyak perangkat keras kuantum yang secara native mendukung fungsi kompiler, fitur ini akan diperluas untuk menyertakan perangkat ini. Perangkat yang mendukung kompilasi kata demi kata menyertakannya sebagai operasi yang didukung saat ditanyakan dengan kode berikut.

```
from braket.aws import AwsDevice
from braket.device_schema.device_action_properties import DeviceActionType
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
device.properties.action[DeviceActionType.OPENQASM].supportedPragmas
```

Tidak ada biaya tambahan yang terkait dengan penggunaan kompilasi kata demi kata. [Anda terus dikenakan biaya untuk tugas kuantum yang dijalankan pada perangkat Braket QPU, instans notebook, dan simulator sesuai permintaan berdasarkan tarif saat ini sebagaimana ditentukan pada halaman Harga Amazon Braket.](https://aws.amazon.com/braket/pricing/) Untuk informasi selengkapnya, lihat buku catatan [contoh kompilasi Verbatim](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Verbatim_Compilation.ipynb).

**catatan**  
Jika Anda menggunakan OpenQASM untuk menulis sirkuit Anda untuk IonQ perangkat AQT dan, dan Anda ingin memetakan sirkuit Anda langsung ke qubit fisik, Anda perlu menggunakan `#pragma braket verbatim` sebagai `disableQubitRewiring` bendera diabaikan oleh OpenQASM.

## Simulasi kebisingan


Untuk membuat instance simulator kebisingan lokal, Anda dapat mengubah backend sebagai berikut.

```
# Import the device module
from braket.aws import AwsDevice

device = LocalSimulator(backend="braket_dm")
```

Anda dapat membangun sirkuit berisik dengan dua cara:

1. Bangun sirkuit berisik dari bawah ke atas.

1. Ambil sirkuit bebas kebisingan yang ada dan suntikkan kebisingan ke seluruh bagian.

Contoh berikut menunjukkan pendekatan menggunakan sirkuit dasar dengan kebisingan depolarisasi dan saluran Kraus khusus.

```
import scipy.stats
import numpy as np

# Bottom up approach
# Apply depolarizing noise to qubit 0 with probability of 0.1
circ = Circuit().x(0).x(1).depolarizing(0, probability=0.1)

# Create an arbitrary 2-qubit Kraus channel
E0 = scipy.stats.unitary_group.rvs(4) * np.sqrt(0.8)
E1 = scipy.stats.unitary_group.rvs(4) * np.sqrt(0.2)
K = [E0, E1]

# Apply a two-qubit Kraus channel to qubits 0 and 2
circ = circ.kraus([0, 2], K)
```

```
from braket.circuits import Noise

# Inject noise approach
# Define phase damping noise
noise = Noise.PhaseDamping(gamma=0.1)
# The noise channel is applied to all the X gates in the circuit
circ = Circuit().x(0).y(1).cnot(0, 2).x(1).z(2)
circ_noise = circ.copy()
circ_noise.apply_gate_noise(noise, target_gates=Gate.X)
```

Menjalankan sirkuit adalah pengalaman pengguna yang sama seperti sebelumnya, seperti yang ditunjukkan dalam dua contoh berikut.

 **Contoh 1** 

```
task = device.run(circ, shots=100)
```

Atau

 **Contoh 2** 

```
task = device.run(circ_noise, shots=100)
```

Untuk contoh lainnya, lihat [contoh simulator bising pengantar Braket](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Simulating_Noise_On_Amazon_Braket.ipynb) 

# Memeriksa sirkuit


Sirkuit kuantum di Amazon Braket memiliki konsep pseudo-time yang disebut `Moments`. Masing-masing qubit dapat mengalami satu gerbang per`Moment`. Tujuannya `Moments` adalah untuk membuat sirkuit dan gerbangnya lebih mudah diatasi dan menyediakan struktur temporal.

**catatan**  
Momen umumnya tidak sesuai dengan waktu nyata di mana gerbang dieksekusi di QPU.

Kedalaman sirkuit diberikan oleh jumlah total Momen di sirkuit tersebut. Anda dapat melihat kedalaman sirkuit memanggil metode `circuit.depth` seperti yang ditunjukkan pada contoh berikut.

```
from braket.circuits import Circuit

# Define a circuit with parametrized gates
circ = Circuit().rx(0, 0.15).ry(1, 0.2).cnot(0, 2).zz(1, 3, 0.15).x(0)
print(circ)
print('Total circuit depth:', circ.depth)
```

```
T  : │     0      │        1         │  2  │
      ┌──────────┐                    ┌───┐ 
q0 : ─┤ Rx(0.15) ├───●────────────────┤ X ├─
      └──────────┘   │                └───┘ 
      ┌──────────┐   │   ┌──────────┐       
q1 : ─┤ Ry(0.20) ├───┼───┤ ZZ(0.15) ├───────
      └──────────┘   │   └────┬─────┘       
                   ┌─┴─┐      │             
q2 : ──────────────┤ X ├──────┼─────────────
                   └───┘      │             
                         ┌────┴─────┐       
q3 : ────────────────────┤ ZZ(0.15) ├───────
                         └──────────┘       
T  : │     0      │        1         │  2  │
Total circuit depth: 3
```

Kedalaman rangkaian total rangkaian di atas adalah 3 (ditunjukkan sebagai momen`0`,`1`, dan`2`). Anda dapat memeriksa operasi gerbang untuk setiap momen.

 `Moments`berfungsi sebagai kamus pasangan *kunci-nilai*.
+ Kuncinya adalah`MomentsKey()`, yang berisi pseudo-time dan qubit informasi.
+ Nilai yang ditetapkan pada jenis `Instructions()`.

```
moments = circ.moments
for key, value in moments.items():
    print(key)
    print(value, "\n")
```

```
MomentsKey(time=0, qubits=QubitSet([Qubit(0)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0, subindex=0)
Instruction('operator': Rx('angle': 0.15, 'qubit_count': 1), 'target': QubitSet([Qubit(0)]), 'control': QubitSet([]), 'control_state': (), 'power': 1) 

MomentsKey(time=0, qubits=QubitSet([Qubit(1)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0, subindex=0)
Instruction('operator': Ry('angle': 0.2, 'qubit_count': 1), 'target': QubitSet([Qubit(1)]), 'control': QubitSet([]), 'control_state': (), 'power': 1) 

MomentsKey(time=1, qubits=QubitSet([Qubit(0), Qubit(2)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0, subindex=0)
Instruction('operator': CNot('qubit_count': 2), 'target': QubitSet([Qubit(0), Qubit(2)]), 'control': QubitSet([]), 'control_state': (), 'power': 1) 

MomentsKey(time=1, qubits=QubitSet([Qubit(1), Qubit(3)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0, subindex=0)
Instruction('operator': ZZ('angle': 0.15, 'qubit_count': 2), 'target': QubitSet([Qubit(1), Qubit(3)]), 'control': QubitSet([]), 'control_state': (), 'power': 1) 

MomentsKey(time=2, qubits=QubitSet([Qubit(0)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0, subindex=0)
Instruction('operator': X('qubit_count': 1), 'target': QubitSet([Qubit(0)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)
```

Anda juga dapat menambahkan gerbang ke sirkuit melalui `Moments`.

```
from braket.circuits import Instruction, Gate

new_circ = Circuit()
instructions = [Instruction(Gate.S(), 0),
                Instruction(Gate.CZ(), [1, 0]),
                Instruction(Gate.H(), 1)
                ]

new_circ.moments.add(instructions)
print(new_circ)
```

```
T  : │  0  │  1  │  2  │
      ┌───┐ ┌───┐       
q0 : ─┤ S ├─┤ Z ├───────
      └───┘ └─┬─┘       
              │   ┌───┐ 
q1 : ─────────●───┤ H ├─
                  └───┘ 
T  : │  0  │  1  │  2  │
```

# Daftar jenis hasil


Amazon Braket dapat mengembalikan berbagai jenis hasil ketika sirkuit diukur menggunakan `ResultType`. Sirkuit dapat mengembalikan jenis hasil berikut.
+  `AdjointGradient`mengembalikan gradien (turunan vektor) dari nilai ekspektasi dari observable yang disediakan. Observable ini bekerja pada target yang diberikan sehubungan dengan parameter yang ditentukan menggunakan metode diferensiasi adjoint. Anda hanya dapat menggunakan metode ini ketika shots=0.
+  `Amplitude`mengembalikan amplitudo keadaan kuantum tertentu dalam fungsi gelombang keluaran. Ini hanya tersedia di simulator lokal SV1 dan lokal.
+  `Expectation`mengembalikan nilai ekspektasi dari observable yang diberikan, yang dapat ditentukan dengan `Observable` kelas diperkenalkan nanti dalam chapter ini. Target yang qubits digunakan untuk mengukur yang dapat diamati harus ditentukan, dan jumlah target yang ditentukan harus sama dengan jumlah qubits tindakan yang dapat diamati. Jika tidak ada target yang ditentukan, observable harus beroperasi hanya pada 1 qubit dan diterapkan ke semua secara qubits paralel.
+  `Probability`mengembalikan probabilitas pengukuran keadaan basis komputasi. Jika target tidak ditentukan, `Probability` mengembalikan probabilitas mengukur semua keadaan dasar. Jika target ditentukan, hanya probabilitas marjinal dari vektor dasar pada yang ditentukan yang dikembalikan. qubits Simulator terkelola dan QPUs dibatasi hingga maksimum 15 qubit, dan simulator lokal terbatas pada ukuran memori sistem.
+  `Reduced density matrix`mengembalikan matriks kepadatan untuk subsistem target tertentu qubits dari sistem. qubits Untuk membatasi ukuran jenis hasil ini, Braket membatasi jumlah target qubits hingga maksimal 8.
+  `StateVector`mengembalikan vektor status penuh. Ini tersedia di simulator lokal.
+  `Sample`mengembalikan jumlah pengukuran dari qubit set target tertentu dan dapat diamati. Jika tidak ada target yang ditentukan, observable harus beroperasi hanya pada 1 qubit dan diterapkan ke semua secara qubits paralel. Jika target ditentukan, jumlah target yang ditentukan harus sama dengan jumlah qubits tindakan yang dapat diamati.
+  `Variance`mengembalikan varians (`mean([x-mean(x)]2)`) dari qubit set target yang ditentukan dan dapat diamati sebagai jenis hasil yang diminta. Jika tidak ada target yang ditentukan, observable harus beroperasi hanya pada 1 qubit dan diterapkan ke semua secara qubits paralel. Jika tidak, jumlah target yang ditentukan harus sama dengan jumlah qubits yang dapat diamati dapat diterapkan.

 **Jenis hasil yang didukung untuk penyedia yang berbeda:** 


|  |  |  |  |  |  |  |  |  | 
| --- |--- |--- |--- |--- |--- |--- |--- |--- |
|  |  Sim lokal  |   SV1   |   DM1   |   TN1   |   AQT   |   IonQ   |   IQM   |   Rigetti   | 
|  Gradien bersebelahan  |  T  |  Y  |  T  |  T  |  T  |  T  |  T  |  T  | 
|  Amplitudo  |  Y  |  Y  |  T  |  T  |  T  |  T  |  T  |  T  | 
|  Perkiraan  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  | 
|  probabilitas  |  Y  |  Y  |  Y  |  T  |  Y  |  Y  |  Y  |  Y  | 
|  Mengurangi matriks kepadatan  |  Y  |  T  |  Y  |  T  |  T  |  T  |  T  |  T  | 
|  Vektor keadaan  |  Y  |  T  |  T  |  T  |  T  |  T  |  T  |  T  | 
|  Sampel  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  | 
|  Varians  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  | 

Anda dapat memeriksa jenis hasil yang didukung dengan memeriksa properti perangkat, seperti yang ditunjukkan pada contoh berikut.

```
from braket.aws import AwsDevice

device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")

# Print the result types supported by this device
for iter in device.properties.action['braket.ir.openqasm.program'].supportedResultTypes:
    print(iter)
```

```
name='Sample' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Expectation' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Variance' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Probability' observables=None minShots=10 maxShots=50000
```

Untuk memanggil a`ResultType`, tambahkan ke sirkuit, seperti yang ditunjukkan pada contoh berikut.

```
from braket.circuits import Circuit, Observable

circ = Circuit().h(0).cnot(0, 1).amplitude(state=["01", "10"])
circ.probability(target=[0, 1])
circ.probability(target=0)
circ.expectation(observable=Observable.Z(), target=0)
circ.sample(observable=Observable.X(), target=0)
circ.state_vector()
circ.variance(observable=Observable.Z(), target=0)

# Print one of the result types assigned to the circuit
print(circ.result_types[0])
```

**catatan**  
Perangkat kuantum yang berbeda memberikan hasil dalam berbagai format. Misalnya, Rigetti perangkat mengembalikan pengukuran, sementara IonQ perangkat memberikan probabilitas. Amazon Braket SDK menawarkan properti pengukuran untuk semua hasil. Namun, untuk perangkat yang mengembalikan probabilitas, pengukuran ini dihitung pasca-perhitungan dan berdasarkan probabilitas, karena pengukuran per tembakan tidak tersedia. Untuk menentukan apakah suatu hasil telah dihitung setelah dihitung, periksa `measurements_copied_from_device` pada objek hasil. Operasi ini dirinci dalam file [gate\$1model\$1quantum\$1task\$1result.py di repositori](https://github.com/aws/amazon-braket-sdk-python/blob/ca5b08dada4839ca31c012ff50aa20b656fd1879/src/braket/tasks/gate_model_quantum_task_result.py#L70-L72) SDK GitHub Amazon Braket.

## Hasil pengamatan


`Observable`Kelas Amazon Braket memungkinkan Anda mengukur pengamatan tertentu. 

Anda hanya dapat menerapkan satu non-identitas unik yang dapat diamati untuk masing-masing. qubit Terjadi kesalahan Jika Anda menentukan dua atau lebih yang dapat diamati non-identitas yang berbeda untuk hal yang sama. qubit Untuk tujuan ini, setiap faktor produk tensor dihitung sebagai individu yang dapat diamati. Ini berarti Anda dapat memiliki beberapa produk tensor yang samaqubit, selama faktor-faktor yang bekerja pada itu qubit tetap sama.

Observable dapat diskalakan dan menambahkan observable lainnya (diskalakan atau tidak). Ini menciptakan `Sum` yang dapat digunakan dalam tipe `AdjointGradient` hasil.

`Observable`Kelas ini mencakup observable berikut.

```
import numpy as np

Observable.I()
Observable.H()
Observable.X()
Observable.Y()
Observable.Z()

# Get the eigenvalues of the observable
print("Eigenvalue:", Observable.H().eigenvalues)
# Or rotate the basis to be computational basis
print("Basis rotation gates:", Observable.H().basis_rotation_gates)

# Get the tensor product of the observable for the multi-qubit case
tensor_product = Observable.Y() @ Observable.Z()
# View the matrix form of an observable by using
print("The matrix form of the observable:\n", Observable.Z().to_matrix())
print("The matrix form of the tensor product:\n", tensor_product.to_matrix())

# Factorize an observable in the tensor form
print("Factorize an observable:", tensor_product.factors)

# Self-define observables, given it is a Hermitian
print("Self-defined Hermitian:", Observable.Hermitian(matrix=np.array([[0, 1], [1, 0]])))

print("Sum of other (scaled) observables:", 2.0 * Observable.X() @ Observable.X() + 4.0 * Observable.Z() @ Observable.Z())
```

```
Eigenvalue: [ 1. -1.]
Basis rotation gates: (Ry('angle': -0.7853981633974483, 'qubit_count': 1),)
The matrix form of the observable:
 [[ 1.+0.j  0.+0.j]
 [ 0.+0.j -1.+0.j]]
The matrix form of the tensor product:
 [[ 0.+0.j  0.+0.j  0.-1.j  0.+0.j]
 [ 0.+0.j -0.+0.j  0.+0.j  0.+1.j]
 [ 0.+1.j  0.+0.j  0.+0.j  0.+0.j]
 [ 0.+0.j  0.-1.j  0.+0.j -0.+0.j]]
Factorize an observable: (Y('qubit_count': 1), Z('qubit_count': 1))
Self-defined Hermitian: Hermitian('qubit_count': 1, 'matrix': [[0.+0.j 1.+0.j], [1.+0.j 0.+0.j]])
Sum of other (scaled) observables: Sum(TensorProduct(X('qubit_count': 1), X('qubit_count': 1)), TensorProduct(Z('qubit_count': 1), Z('qubit_count': 1)))
```

## Parameter


Sirkuit dapat menggabungkan parameter gratis. Parameter gratis ini hanya perlu dibangun sekali untuk dijalankan beberapa kali, dan dapat digunakan untuk menghitung gradien. 

Setiap parameter gratis menggunakan nama yang disandikan string yang digunakan untuk: 
+ Tetapkan nilai parameter
+ Identifikasi parameter mana yang akan digunakan

```
from braket.circuits import Circuit, FreeParameter, observables
from braket.parametric import FreeParameter

theta = FreeParameter("theta")
phi = FreeParameter("phi")
circ = Circuit().h(0).rx(0, phi).ry(0, phi).cnot(0, 1).xx(0, 1, theta)
```

## Gradien bersebelahan


SV1Perangkat menghitung gradien berdampingan dari nilai ekspektasi yang dapat diamati, termasuk Hamiltonian multi-term. Untuk membedakan parameter, tentukan namanya (dalam format string) atau dengan referensi langsung.

```
from braket.aws import AwsDevice
from braket.devices import Devices

device = AwsDevice(Devices.Amazon.SV1)

circ.adjoint_gradient(observable=3 * Observable.Z(0) @ Observable.Z(1) - 0.5 * observables.X(0), parameters = ["phi", theta])
```

Melewati nilai parameter tetap sebagai argumen ke sirkuit berparameter akan menghapus parameter bebas. Menjalankan sirkuit ini dengan `AdjointGradient` menghasilkan kesalahan, karena parameter bebas tidak ada lagi. Contoh kode berikut menunjukkan penggunaan yang benar dan salah:

```
# Will error, as no free parameters will be present
#device.run(circ(0.2), shots=0)

# Will succeed
device.run(circ, shots=0, inputs={'phi': 0.2, 'theta': 0.2})
```

# Mendapatkan saran ahli


Terhubung dengan pakar komputasi kuantum langsung di konsol manajemen Braket untuk mendapatkan panduan tambahan seputar beban kerja Anda. 

**Untuk menjelajahi opsi saran ahli melalui Braket Direct, buka konsol Braket, pilih **Braket Direct** di panel kiri, dan arahkan ke bagian Saran ahli.** Opsi saran Ahli berikut tersedia:
+ **Jam kantor Braket: Jam** kantor Braket adalah sesi 1:1, pertama datang pertama dilayani, dan berlangsung setiap bulan. Setiap slot jam kantor yang tersedia adalah 30 menit dan gratis. Berbicara dengan pakar Braket dapat membantu Anda beralih dari ide ke eksekusi lebih cepat dengan menjelajahi use-case-to-device kecocokan, mengidentifikasi opsi untuk menggunakan Braket terbaik untuk algoritme Anda, dan mendapatkan rekomendasi tentang cara menggunakan fitur Braket tertentu seperti Pekerjaan Hibrid Amazon Braket, Pulsa Braket, atau Simulasi Hamiltonian Analog.
  + Untuk mendaftar jam kantor Braket, pilih **Daftar** dan isi informasi kontak, detail beban kerja, dan topik diskusi yang Anda inginkan.
  + Anda akan menerima undangan kalender ke slot berikutnya yang tersedia melalui email Anda.
**catatan**  
[Untuk masalah yang muncul atau pertanyaan pemecahan masalah cepat, kami sarankan untuk menghubungi Support.AWS](https://console.aws.amazon.com/support/home#/case/create?issueType=technical) Untuk pertanyaan yang tidak mendesak, Anda juga dapat menggunakan [forum AWS Re:Post](https://repost.aws/tags/questions/TAhMWeHkpfSMSCxIFNqcqYog?view=all) atau [Quantum Computing Stack Exchange](https://quantumcomputing.stackexchange.com/questions/ask), tempat Anda dapat menelusuri pertanyaan yang dijawab sebelumnya dan mengajukan pertanyaan baru.
+ **Penawaran penyedia perangkat keras kuantum:**IonQ,QuEra, dan Rigetti masing-masing menyediakan penawaran layanan profesional melalui. AWS Marketplace
  + Untuk menjelajahi penawaran mereka, pilih **Connect** dan telusuri daftar mereka.
  + Untuk mempelajari lebih lanjut tentang penawaran layanan profesional di AWS Marketplace, lihat Produk [layanan profesional](https://docs.aws.amazon.com/marketplace/latest/buyerguide/buyer-proserv-products.html).
+ **AmazonQuantum Solutions Lab (QSL):** QSL adalah tim penelitian kolaboratif dan layanan profesional yang dikelola oleh para ahli komputasi kuantum yang dapat membantu Anda menjelajahi komputasi kuantum secara efektif dan menilai kinerja teknologi saat ini.
  + Untuk menghubungi QSL, pilih **Connect**, dan isi informasi kontak dan detail kasus penggunaan.
  + Tim QSL akan menghubungi Anda melalui email dengan langkah selanjutnya.

# Jalankan sirkuit Anda dengan OpenQASM 3.0
(Advanced) Jalankan sirkuit Anda dengan OpenQASM 3.0

 AmazonBraket sekarang mendukung [OpenQASM 3.0](https://openqasm.com/) untuk perangkat kuantum berbasis gerbang dan simulator. Panduan pengguna ini memberikan informasi tentang subset OpenQASM 3.0 yang didukung oleh Braket. [https://docs.aws.amazon.com/braket/latest/APIReference/Welcome.html](https://docs.aws.amazon.com/braket/latest/APIReference/Welcome.html)

Topik dalam panduan ini memandu Anda melalui berbagai contoh cara menyelesaikan tugas kuantum berikut.
+  [Buat dan kirimkan tugas kuantum OpenQASM pada perangkat Braket yang berbeda](braket-openqasm-create-submit-task.md) 
+  [Akses operasi dan jenis hasil yang didukung](braket-openqasm-device-support.md#braket-openqasm-supported-operations-results-result-types) 
+  [Simulasikan kebisingan dengan OpenQASM](braket-openqasm-noise-simulation.md) 
+  [Gunakan kompilasi kata demi kata dengan OpenQASM](braket-openqasm-verbatim-compilation.md) 
+  [Memecahkan masalah OpenQASM](https://docs.aws.amazon.com/braket/latest/developerguide/braket-troubleshooting-openqasm.html) 

Panduan ini juga memberikan pengenalan fitur khusus perangkat keras tertentu yang dapat diimplementasikan dengan OpenQASM 3.0 pada Braket dan tautan ke sumber daya lebih lanjut.

**Topics**
+ [

## Apa itu OpenQASM 3.0?
](#braket-openqasm-what-is)
+ [

## Kapan menggunakan OpenQASM 3.0
](#braket-openqasm-when-to-use)
+ [

## Bagaimana OpenQASM 3.0 bekerja
](#braket-openqasm-how-it-works)
+ [

## Prasyarat
](#braket-openqasm-prerequisites)
+ [

# Fitur OpenQASM apa yang didukung Braket?
](braket-openqasm-supported-features.md)
+ [

# Buat dan kirimkan contoh tugas kuantum OpenQASM 3.0
](braket-openqasm-create-submit-task.md)
+ [

# Support untuk OpenQASM pada perangkat Braket yang berbeda
](braket-openqasm-device-support.md)
+ [

# Simulasikan kebisingan dengan OpenQASM 3.0
](braket-openqasm-noise-simulation.md)
+ [

# Qubitrewiring dengan OpenQASM 3.0
](braket-openqasm-rewire-qubits.md)
+ [

# Kompilasi verbatim dengan OpenQASM 3.0
](braket-openqasm-verbatim-compilation.md)
+ [

## Konsol Braket
](#braket-openqasm-braket-console)
+ [

## Sumber daya tambahan
](#braket-openqasm-more-resources)
+ [

# Gradien komputasi dengan OpenQASM 3.0
](braket-openqasm-computing-gradients.md)
+ [

# Mengukur qubit tertentu dengan OpenQASM 3.0
](braket-openqasm-measure-qubits.md)

## Apa itu OpenQASM 3.0?


Open Quantum Assembly Language (OpenQASM) adalah [representasi perantara](https://en.wikipedia.org/wiki/Intermediate_representation) untuk instruksi kuantum. OpenQASM adalah kerangka kerja sumber terbuka dan banyak digunakan untuk spesifikasi program kuantum untuk perangkat berbasis gerbang. Dengan OpenQASM, pengguna dapat memprogram gerbang kuantum dan operasi pengukuran yang membentuk blok bangunan komputasi kuantum. Versi sebelumnya dari OpenQASM (2.0) digunakan oleh sejumlah perpustakaan pemrograman kuantum untuk menggambarkan program dasar.

Versi baru OpenQASM (3.0) memperluas versi sebelumnya untuk menyertakan lebih banyak fitur, seperti kontrol tingkat pulsa, waktu gerbang, dan aliran kontrol klasik untuk menjembatani kesenjangan antara antarmuka pengguna akhir dan bahasa deskripsi perangkat keras. Detail dan spesifikasi pada versi 3.0 saat ini tersedia di GitHub [OpenQASM 3.x](https://github.com/openqasm/openqasm) Live Specification. Pengembangan future OpenQASM diatur oleh OpenQASM 3.0 [Technical Steering Committee](https://aws.amazon.com/blogs/quantum-computing/aws-joins-the-openqasm-3-0-technical-steering-committee/), yang merupakan AWS anggota bersama IBM, Microsoft, dan University of Innsbruck.

## Kapan menggunakan OpenQASM 3.0


OpenQASM menyediakan kerangka kerja ekspresif untuk menentukan program kuantum melalui kontrol tingkat rendah yang tidak spesifik arsitektur, membuatnya cocok sebagai representasi di beberapa perangkat berbasis gerbang. Dukungan Braket untuk OpenQASM memajukan adopsi sebagai pendekatan yang konsisten untuk mengembangkan algoritma kuantum berbasis gerbang, mengurangi kebutuhan pengguna untuk belajar dan memelihara perpustakaan dalam berbagai kerangka kerja.

Jika Anda memiliki pustaka program yang ada di OpenQASM 3.0, Anda dapat menyesuaikannya untuk digunakan dengan Braket daripada menulis ulang sirkuit ini sepenuhnya. Peneliti dan pengembang juga harus mendapat manfaat dari peningkatan jumlah perpustakaan pihak ketiga yang tersedia dengan dukungan untuk pengembangan algoritma di OpenQASM.

## Bagaimana OpenQASM 3.0 bekerja


Support untuk OpenQASM 3.0 dari Braket memberikan paritas fitur dengan Representasi Menengah saat ini. Ini berarti bahwa apa pun yang dapat Anda lakukan hari ini pada perangkat keras dan simulator sesuai permintaan dengan Braket, Anda dapat melakukannya dengan OpenQASM menggunakan Braket. API Anda dapat menjalankan program OpenQASM 3.0 dengan langsung memasok string OpenQASM ke semua perangkat berbasis gerbang dengan cara yang mirip dengan bagaimana sirkuit saat ini dipasok ke perangkat di Braket. Pengguna Braket juga dapat mengintegrasikan pustaka pihak ketiga yang mendukung OpenQASM 3.0. Sisa panduan ini merinci bagaimana mengembangkan representasi OpenQASM untuk digunakan dengan Braket.

## Prasyarat


[Untuk menggunakan OpenQASM 3.0 di Amazon Braket, Anda harus memiliki versi v1.8.0 dari Skema Python Amazon [Braket dan v1.17.0 atau lebih tinggi dari Amazon Braket Python](https://github.com/aws/amazon-braket-schemas-python) SDK.](https://github.com/aws/amazon-braket-sdk-python)

Jika Anda adalah pengguna pertama kali Amazon Braket, Anda harus mengaktifkan Amazon Braket. Untuk petunjuk, lihat [Mengaktifkan Amazon Braket](https://docs.aws.amazon.com/braket/latest/developerguide/braket-enable-overview.html).

# Fitur OpenQASM apa yang didukung Braket?


Bagian berikut mencantumkan tipe data OpenQASM 3.0, pernyataan, dan instruksi pragma yang didukung oleh Braket.

**Topics**
+ [

## Tipe data OpenQASM yang didukung
](#braket-openqasm-supported-features-datatypes)
+ [

## Pernyataan OpenQASM yang didukung
](#braket-openqasm-supported-features-statements)
+ [

## Braket OpenQASM pragma
](#braket-openqasm-supported-features-pragmas)
+ [

## Dukungan fitur lanjutan untuk OpenQASM di Simulator Lokal
](#braket-openqasm-supported-features-advanced-feature-local-simulator)
+ [

## Operasi dan tata bahasa yang didukung dengan OpenPulse
](#braket-openpulse-supported-operations-grammar)

## Tipe data OpenQASM yang didukung


Tipe data OpenQASM berikut didukung oleh Amazon Braket.
+ Bilangan bulat non-negatif digunakan untuk indeks qubit (virtual dan fisik):
  +  `cnot q[0], q[1];` 
  +  `h $0;` 
+ Angka atau konstanta floating-point dapat digunakan untuk sudut rotasi gerbang:
  +  `rx(-0.314) $0;` 
  +  `rx(pi/4) $0;` 

**catatan**  
pi adalah konstanta bawaan di OpenQASM dan tidak dapat digunakan sebagai nama parameter.
+ Array bilangan kompleks (dengan `im` notasi openQASM untuk bagian imajiner) diizinkan dalam pragma tipe hasil untuk mendefinisikan hermitian umum yang dapat diamati dan dalam pragma kesatuan:
  +  `#pragma braket unitary [[0, -1im], [1im, 0]] q[0]` 
  +  `#pragma braket result expectation hermitian([[0, -1im], [1im, 0]]) q[0]` 

## Pernyataan OpenQASM yang didukung


Pernyataan OpenQASM berikut didukung oleh Amazon Braket.
+  `Header: OPENQASM 3;` 
+ Deklarasi bit klasik:
  +  `bit b1;`(setara,) `creg b1;`
  +  `bit[10] b2;`(setara,) `creg b2[10];`
+ Deklarasi Qubit:
  +  `qubit b1;`(setara,) `qreg b1;`
  +  `qubit[10] b2;`(setara,) `qreg b2[10];`
+ Pengindeksan dalam array: `q[0]` 
+ Masukan: `input float alpha;` 
+ spesifikasi fisikqubits: `$0` 
+ Gerbang dan operasi yang didukung pada perangkat:
  +  `h $0;` 
  +  `iswap q[0], q[1];` 

**catatan**  
Gerbang yang didukung perangkat dapat ditemukan di properti perangkat untuk tindakan OpenQASM; tidak ada definisi gerbang yang diperlukan untuk menggunakan gerbang ini.
+ Pernyataan kotak kata demi kata. Saat ini, kami tidak mendukung notasi durasi kotak. Gerbang asli dan fisik qubits diperlukan dalam kotak kata demi kata.

```
#pragma braket verbatim
box{
    rx(0.314) $0;
}
```
+ Penugasan pengukuran dan pengukuran pada qubits atau seluruh qubit register.
  +  `measure $0;` 
  +  `measure q;` 
  +  `measure q[0];` 
  +  `b = measure q;` 
  +  `measure q → b;` 
+ Pernyataan penghalang memberikan kontrol eksplisit atas kompilasi dan eksekusi sirkuit dengan mencegah penataan ulang gerbang dan pengoptimalan melintasi batas penghalang. Mereka juga menegakkan urutan temporal yang ketat selama eksekusi, memastikan semua operasi sebelum penghalang selesai sebelum operasi berikutnya dimulai.
  +  `barrier;` 
  +  `barrier q[0], q[1];` 
  +  `barrier $3, $6;` 

## Braket OpenQASM pragma


Petunjuk pragma OpenQASM berikut didukung oleh Amazon Braket.
+ Pragma kebisingan
  +  `#pragma braket noise bit_flip(0.2) q[0]` 
  +  `#pragma braket noise phase_flip(0.1) q[0]` 
  +  `#pragma braket noise pauli_channel` 
+ Pragma kata demi kata
  +  `#pragma braket verbatim` 
+ Jenis hasil pragma
  + Jenis hasil invarian dasar:
    + Vektor negara: `#pragma braket result state_vector` 
    + Matriks kepadatan: `#pragma braket result density_matrix` 
  + Pragma perhitungan gradien:
    + Gradien bersebelahan: `#pragma braket result adjoint_gradient expectation(2.2 * x[0] @ x[1]) all` 
  + Jenis hasil dasar Z:
    + Amplitudo: `#pragma braket result amplitude "01"` 
    + Probabilitas: `#pragma braket result probability q[0], q[1]` 
  + Jenis hasil yang diputar dasar
    + Harapan: `#pragma braket result expectation x(q[0]) @ y([q1])` 
    + Varians: `#pragma braket result variance hermitian([[0, -1im], [1im, 0]]) $0` 
    + Sampel: `#pragma braket result sample h($1)` 

**catatan**  
OpenQASM 3.0 kompatibel dengan OpenQASM 2.0, sehingga program yang ditulis menggunakan 2.0 dapat berjalan di Braket. Namun fitur OpenQASM 3.0 yang didukung oleh Braket memang memiliki beberapa perbedaan sintaks kecil, seperti vs dan vs. `qreg` `creg` `qubit` `bit` Ada juga perbedaan dalam sintaks pengukuran, dan ini perlu didukung dengan sintaks yang benar.

## Dukungan fitur lanjutan untuk OpenQASM di Simulator Lokal


Ini `LocalSimulator` mendukung fitur OpenQASM canggih yang tidak ditawarkan sebagai bagian dari simulator QPU atau on-demand Braket. Daftar fitur berikut hanya didukung di`LocalSimulator`:
+ Pengubah gerbang
+ Gerbang bawaan OpenQASM
+ Variabel klasik
+ Operasi klasik
+ Gerbang kustom
+ Kontrol klasik
+ File QASM
+ Subrutin

Untuk contoh setiap fitur lanjutan, lihat [contoh buku catatan](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Simulating_Advanced_OpenQASM_Programs_with_the_Local_Simulator.ipynb) ini. [Untuk spesifikasi OpenQASM lengkap, lihat situs web OpenQASM.](https://openqasm.com/language/index.html)

## Operasi dan tata bahasa yang didukung dengan OpenPulse


 **Tipe OpenPulse Data yang Didukung** 

Blok Cal:

```
cal {
    ...
}
```

Blok Defcal:

```
// 1 qubit
defcal x $0 {
...
}

// 1 qubit w. input parameters as constants
defcal my_rx(pi) $0 {
...
}

// 1 qubit w. input parameters as free parameters
defcal my_rz(angle theta) $0 {
...
}

// 2 qubit (above gate args are also valid)
defcal cz $1, $0 {
...
}
```

Bingkai:

```
frame my_frame = newframe(port_0, 4.5e9, 0.0);
```

Bentuk gelombang:

```
// prebuilt
waveform my_waveform_1 = constant(1e-6, 1.0);

//arbitrary
waveform my_waveform_2 = {0.1 + 0.1im, 0.1 + 0.1im, 0.1, 0.1};
```

 **Contoh Kalibrasi Gerbang Kustom:** 

```
cal {
    waveform wf1 = constant(1e-6, 0.25);
}

defcal my_x $0 {
   play(wf1, q0_rf_frame);
}

defcal my_cz $1, $0 {
    barrier q0_q1_cz_frame, q0_rf_frame;
    play(q0_q1_cz_frame, wf1);
    delay[300ns] q0_rf_frame
    shift_phase(q0_rf_frame, 4.366186381749424);
    delay[300ns] q0_rf_frame;
    shift_phase(q0_rf_frame.phase, 5.916747563126659);
    barrier q0_q1_cz_frame, q0_rf_frame;
    shift_phase(q0_q1_cz_frame, 2.183093190874712);
}

bit[2] ro;
my_x $0;
my_cz $1,$0;
c[0] = measure $0;
```

 **Contoh pulsa sewenang-wenang:** 

```
bit[2] ro;
cal {
    waveform wf1 = {0.1 + 0.1im, 0.1 + 0.1im, 0.1, 0.1};
    barrier q0_drive, q0_q1_cross_resonance;
    play(q0_q1_cross_resonance, wf1);
    delay[300ns] q0_drive;
    shift_phase(q0_drive, 4.366186381749424);
    delay[300dt] q0_drive;
   barrier q0_drive, q0_q1_cross_resonance;
   play(q0_q1_cross_resonance, wf1);
    ro[0] = capture_v0(r0_measure);
    ro[1] = capture_v0(r1_measure);
}
```

# Buat dan kirimkan contoh tugas kuantum OpenQASM 3.0


Anda dapat menggunakan Amazon Braket Python SDK, Boto3, atau AWS CLI untuk mengirimkan tugas kuantum OpenQASM 3.0 ke perangkat Amazon Braket.

**Topics**
+ [

## Contoh program OpenQASM 3.0
](#braket-openqasm-example-program)
+ [

## Gunakan Python SDK untuk membuat tugas kuantum OpenQASM 3.0
](#braket-openqasm-create-tasks-with-python-sdk)
+ [

## Gunakan Boto3 untuk membuat tugas kuantum OpenQASM 3.0
](#braket-openqasm-create-tasks-with-boto3)
+ [

## Gunakan AWS CLI untuk membuat tugas OpenQASM 3.0
](#braket-openqasm-create-tasks-with-aws-cli)

## Contoh program OpenQASM 3.0


[Untuk membuat tugas OpenQASM 3.0, Anda dapat memulai dengan program OpenQASM 3.0 dasar (ghz.qasm) yang menyiapkan status GHZ seperti yang ditunjukkan pada contoh berikut.](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state)

```
// ghz.qasm
// Prepare a GHZ state
OPENQASM 3;

qubit[3] q;
bit[3] c;

h q[0];
cnot q[0], q[1];
cnot q[1], q[2];

c = measure q;
```

## Gunakan Python SDK untuk membuat tugas kuantum OpenQASM 3.0


Anda dapat menggunakan [Amazon Braket Python SDK](https://github.com/aws/amazon-braket-sdk-python) untuk mengirimkan program ini ke perangkat Amazon Braket dengan kode berikut. Pastikan untuk mengganti contoh lokasi bucket Amazon S3 “amzn-s3-demo-bucket” dengan nama bucket Amazon S3 Anda sendiri.

```
with open("ghz.qasm", "r") as ghz:
    ghz_qasm_string = ghz.read()

# Import the device module
from braket.aws import AwsDevice
# Choose the Rigetti device
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
from braket.ir.openqasm import Program

program = Program(source=ghz_qasm_string)
my_task = device.run(program)

# Specify an optional s3 bucket location and number of shots
s3_location = ("amzn-s3-demo-bucket", "openqasm-tasks")
my_task = device.run(
    program,
    s3_location,
    shots=100,
)
```

## Gunakan Boto3 untuk membuat tugas kuantum OpenQASM 3.0


Anda juga dapat menggunakan [AWS Python SDK untuk Braket (Boto3) untuk](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/braket.html) membuat tugas kuantum menggunakan string OpenQASM 3.0, seperti yang ditunjukkan pada contoh berikut. [Cuplikan kode berikut referensi ghz.qasm yang menyiapkan status GHZ seperti yang ditunjukkan di atas.](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state)

```
import boto3
import json

my_bucket = "amzn-s3-demo-bucket"
s3_prefix = "openqasm-tasks"

with open("ghz.qasm") as f:
    source = f.read()

action = {
    "braketSchemaHeader": {
        "name": "braket.ir.openqasm.program",
        "version": "1"
    },
    "source": source
}
device_parameters = {}
device_arn = "arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3"
shots = 100

braket_client = boto3.client('braket', region_name='us-west-1')
rsp = braket_client.create_quantum_task(
    action=json.dumps(
        action
    ),
    deviceParameters=json.dumps(
        device_parameters
    ),
    deviceArn=device_arn,
    shots=shots,
    outputS3Bucket=my_bucket,
    outputS3KeyPrefix=s3_prefix,
)
```

## Gunakan AWS CLI untuk membuat tugas OpenQASM 3.0


[AWS Command Line Interface (CLI)](https://aws.amazon.com/cli/) juga dapat digunakan untuk mengirimkan program OpenQASM 3.0, seperti yang ditunjukkan pada contoh berikut.

```
aws braket create-quantum-task \
    --region "us-west-1" \
    --device-arn "arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3" \
    --shots 100 \
    --output-s3-bucket "amzn-s3-demo-bucket" \
    --output-s3-key-prefix "openqasm-tasks" \
    --action '{
        "braketSchemaHeader": {
            "name": "braket.ir.openqasm.program",
            "version": "1"
        },
        "source": $(cat ghz.qasm)
    }'
```

# Support untuk OpenQASM pada perangkat Braket yang berbeda


Untuk perangkat yang mendukung OpenQASM 3.0, `action` bidang ini mendukung tindakan baru melalui `GetDevice` respons, seperti yang ditunjukkan pada contoh berikut untuk perangkat danRigetti. IonQ

```
//OpenQASM as available with the Rigetti device capabilities
{
    "braketSchemaHeader": {
        "name": "braket.device_schema.rigetti.rigetti_device_capabilities",
        "version": "1"
    },
    "service": {...},
    "action": {
        "braket.ir.jaqcd.program": {...},
        "braket.ir.openqasm.program": {
            "actionType": "braket.ir.openqasm.program",
            "version": [
                "1"
            ],
            ….
        }
    }
}

//OpenQASM as available with the IonQ device capabilities
{
    "braketSchemaHeader": {
        "name": "braket.device_schema.ionq.ionq_device_capabilities",
        "version": "1"
    },
    "service": {...},
    "action": {
        "braket.ir.jaqcd.program": {...},
        "braket.ir.openqasm.program": {
            "actionType": "braket.ir.openqasm.program",
            "version": [
                "1"
            ],
            ….
        }
    }
}
```

Untuk perangkat yang mendukung kontrol pulsa, `pulse` bidang ditampilkan dalam `GetDevice` respons. Contoh berikut menunjukkan `pulse` bidang ini untuk Rigetti perangkat.

```
// Rigetti
{
  "pulse": {
    "braketSchemaHeader": {
      "name": "braket.device_schema.pulse.pulse_device_action_properties",
      "version": "1"
    },
    "supportedQhpTemplateWaveforms": {
      "constant": {
        "functionName": "constant",
        "arguments": [
          {
            "name": "length",
            "type": "float",
            "optional": false
          },
          {
            "name": "iq",
            "type": "complex",
            "optional": false
          }
        ]
      },
      ...
    },
    "ports": {
      "q0_ff": {
        "portId": "q0_ff",
        "direction": "tx",
        "portType": "ff",
        "dt": 1e-9,
        "centerFrequencies": [
          375000000
        ]
      },
      ...
    },
    "supportedFunctions": {
      "shift_phase": {
        "functionName": "shift_phase",
        "arguments": [
          {
            "name": "frame",
            "type": "frame",
            "optional": false
          },
          {
            "name": "phase",
            "type": "float",
            "optional": false
          }
        ]
      },
     ...
    },
    "frames": {
      "q0_q1_cphase_frame": {
        "frameId": "q0_q1_cphase_frame",
        "portId": "q0_ff",
        "frequency": 462475694.24460185,
        "centerFrequency": 375000000,
        "phase": 0,
        "associatedGate": "cphase",
        "qubitMappings": [
          0,
          1
        ]
      },
      ...
    },
    "supportsLocalPulseElements": false,
    "supportsDynamicFrames": false,
    "supportsNonNativeGatesWithPulses": false,
    "validationParameters": {
      "MAX_SCALE": 4,
      "MAX_AMPLITUDE": 1,
      "PERMITTED_FREQUENCY_DIFFERENCE": 400000000
    }
  }
}
```

Bidang sebelumnya merinci hal-hal berikut:

 **Pelabuhan:** 

Menjelaskan port perangkat eksternal (`extern`) yang telah dibuat sebelumnya yang dideklarasikan pada QPU selain properti terkait dari port yang diberikan. Semua port yang tercantum dalam struktur ini dideklarasikan sebelumnya sebagai pengidentifikasi yang valid dalam `OpenQASM 3.0` program yang dikirimkan oleh pengguna. Properti tambahan untuk port meliputi:
+ Id port (PortID)
  + Nama port dinyatakan sebagai identifier di OpenQASM 3.0.
+ Arah (arah)
  + Arah pelabuhan. Port drive mengirimkan pulsa (arah “tx”), sedangkan port pengukuran menerima pulsa (arah “rx”).
+ Jenis port (PortType)
  + Jenis tindakan yang menjadi tanggung jawab port ini (misalnya, drive, capture, atau ff - fast-flux).
+ Dt (dt)
  + Waktu dalam detik yang mewakili satu langkah waktu sampel pada port yang diberikan.
+ Pemetaan Qubit (QubitMappings)
  + Qubit yang terkait dengan port yang diberikan.
+ Frekuensi tengah (CenterFrequencies)
  + Daftar frekuensi pusat terkait untuk semua frame yang telah dideklarasikan atau ditentukan pengguna pada port. Untuk informasi lebih lanjut, lihat Bingkai.
+ Properti Khusus QHP () qhpSpecificProperties
  + Peta opsional yang merinci properti yang ada tentang port khusus untuk QHP.

 **Bingkai:** 

Menjelaskan frame eksternal pra-dibuat yang dideklarasikan pada QPU serta properti terkait tentang frame. Semua frame yang tercantum dalam struktur ini telah dideklarasikan sebelumnya sebagai pengidentifikasi yang valid dalam `OpenQASM 3.0` program yang dikirimkan oleh pengguna. Properti tambahan untuk bingkai meliputi:
+ Id Bingkai (FrameID)
  + Nama frame dinyatakan sebagai identifier di OpenQASM 3.0.
+ Port Id (PortID)
  + Port perangkat keras terkait untuk bingkai.
+ Frekuensi (frekuensi)
  + Frekuensi awal default dari frame.
+ Frekuensi Pusat (Frekuensi Tengah)
  + Pusat bandwidth frekuensi untuk frame. Biasanya, frame hanya dapat disesuaikan dengan bandwidth tertentu di sekitar frekuensi tengah. Akibatnya, penyesuaian frekuensi harus tetap berada dalam delta tertentu dari frekuensi pusat. Anda dapat menemukan nilai bandwidth dalam parameter validasi.
+ Fase (fase)
  + Fase awal default dari frame.
+ Gerbang Terkait (AssociatedGate)
  + Gerbang yang terkait dengan bingkai yang diberikan.
+ Pemetaan Qubit (QubitMappings)
  + Qubit yang terkait dengan frame yang diberikan.
+ Properti Khusus QHP () qhpSpecificProperties
  + Peta opsional yang merinci properti yang ada tentang bingkai khusus untuk QHP.

 **SupportsDynamicFrames:** 

Menjelaskan apakah bingkai dapat dideklarasikan `cal` atau `defcal` diblokir melalui OpenPulse `newframe` fungsi. Jika ini salah, hanya bingkai yang tercantum dalam struktur bingkai yang dapat digunakan dalam program.

 **SupportedFunctions:** 

Menjelaskan OpenPulse fungsi yang didukung untuk perangkat selain argumen terkait, tipe argumen, dan tipe pengembalian untuk fungsi yang diberikan. Untuk melihat contoh penggunaan OpenPulse fungsi, lihat [OpenPulsespesifikasinya](https://openqasm.com/language/openpulse.html). Pada saat ini, Braket mendukung:
+ shift\$1phase
  + Menggeser fase frame dengan nilai yang ditentukan
+ set\$1phase
  + Mengatur fase frame ke nilai yang ditentukan
+ swap\$1phase
  + Menukar fase antara dua frame.
+ shift\$1frequency
  + Menggeser frekuensi frame dengan nilai yang ditentukan
+ set\$1frequency
  + Mengatur frekuensi frame ke nilai yang ditentukan
+ pementasan
  + Menjadwalkan bentuk gelombang
+ menangkap\$1v0
  + Mengembalikan nilai pada frame capture ke register bit

 **SupportedQhpTemplateWaveforms:** 

Menjelaskan fungsi bentuk gelombang yang telah dibuat sebelumnya yang tersedia di perangkat serta argumen serta tipe terkait. Secara default, Braket Pulse menawarkan rutinitas bentuk gelombang pra-bangun pada semua perangkat, yaitu:

 ***Konstan*** 

![\[Persamaan matematika menunjukkan fungsi konstan dengan parameter t, tau, dan iq di mana output selalu sama dengan iq.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/ConstantFunction.png)


 `τ`adalah panjang bentuk gelombang dan `iq` merupakan bilangan kompleks.

```
def constant(length, iq)
```

 ***Gaussian*** 

![\[Persamaan matematika yang menunjukkan fungsi Gaussian dengan parameter t, tau, sigma, A=1, dan ZAE=0.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/GaussianFunction.png)


 `τ`adalah panjang bentuk gelombang, `σ` adalah lebar Gaussian, dan `A` merupakan amplitudo. Jika disetel `ZaE` ke`True`, Gaussian diimbangi dan diskalakan ulang sedemikian rupa sehingga sama dengan nol pada awal dan akhir bentuk gelombang, dan mencapai maksimum. `A`

```
def gaussian(length, sigma, amplitude=1, zero_at_edges=False)
```

 ***DRAG Gaussian*** 

![\[Persamaan matematika untuk distribusi DRAG Gaussian dengan parameter t, tau, sigma, beta, A=1, dan ZAE=0.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/DRAGGaussianFunction.png)


 `τ`adalah panjang bentuk gelombang, `σ` adalah lebar gaussian, adalah parameter bebas, dan `β` `A` merupakan amplitudo. Jika disetel `ZaE` ke`True`, Penghapusan Derivatif oleh Gerbang Adiabatik (DRAG) Gaussian diimbangi dan diskalakan ulang sedemikian rupa sehingga sama dengan nol pada awal dan akhir bentuk gelombang, dan bagian sebenarnya mencapai maksimum. `A` Untuk informasi lebih lanjut tentang bentuk gelombang DRAG, lihat paper [Pulsa Sederhana untuk Penghapusan Kebocoran pada Qubit Nonlinier](https://doi.org/10.1103/PhysRevLett.103.110501) Lemah.

```
def drag_gaussian(length, sigma, beta, amplitude=1, zero_at_edges=False)
```

 ***Alun-alun Erf*** 

![\[Persamaan matematika untuk distribusi Erf Square dengan parameter t, Panjang, Lebar, sigma, A=1, dan ZAE=0.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/ErfSquareFunction.PNG)


Di mana `L` panjangnya, `W` adalah lebar bentuk gelombang, `σ` menentukan seberapa cepat tepi naik dan turun, `t1​=(L−W)/2` dan`t22=(L+W)/2`, `A` adalah amplitudo. Jika disetel `ZaE` ke`True`, Gaussian diimbangi dan diskalakan ulang sedemikian rupa sehingga sama dengan nol pada awal dan akhir bentuk gelombang, dan mencapai maksimum. `A` Persamaan berikut adalah versi bentuk gelombang yang diskalakan ulang.

![\[Persamaan matematika untuk distribusi Erf Square yang diskalakan ulang dengan parameter ZAE=1.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/RescaledErfSquareFunction.PNG)


Dimana `a=erf(W/2σ)` dan`b=erf(-t1​/σ)/2+erf(t2​/σ)/2`.

```
def erf_square(length, width, sigma, amplitude=1, zero_at_edges=False)
```

 **SupportsLocalPulseElements:** 

Menjelaskan apakah elemen pulsa, seperti port, frame, dan bentuk gelombang dapat didefinisikan secara lokal dalam blok. `defcal` Jika nilainya`false`, elemen harus didefinisikan dalam `cal` blok.

 **SupportsNonNativeGatesWithPulses:** 

Menjelaskan apakah kita dapat atau tidak dapat menggunakan gerbang non-asli dalam kombinasi dengan program pulsa. Misalnya, Anda tidak dapat menggunakan gerbang non-asli seperti `H` gerbang dalam program tanpa terlebih dahulu mendefinisikan gerbang `defcal` untuk qubit yang digunakan. Anda dapat menemukan daftar `nativeGateSet` kunci gerbang asli di bawah kemampuan perangkat.

 **ValidationParameters:** 

Menjelaskan batas validasi elemen pulsa, termasuk:
+ Skala Maksimum/Nilai Amplitudo Maksimum untuk bentuk gelombang (arbitrer dan pra-bangun)
+ Bandwidth frekuensi maksimum dari frekuensi pusat yang disediakan dalam Hz
+ Pulsa minimum length/duration dalam hitungan detik
+ Pulsa maksimum length/duration dalam hitungan detik

## Operasi, Hasil, dan Jenis Hasil yang Didukung dengan OpenQASM


Untuk mengetahui fitur OpenQASM 3.0 mana yang didukung setiap perangkat, Anda dapat merujuk ke `braket.ir.openqasm.program` kunci di `action` bidang pada output kemampuan perangkat. Misalnya, berikut ini adalah operasi yang didukung dan jenis hasil yang tersedia untuk simulator SV1 Braket State Vector.

```
...
  "action": {
    "braket.ir.jaqcd.program": {
      ...
    },
 "braket.ir.openqasm.program": {
      "version": [
        "1.0"
      ],
      "actionType": "braket.ir.openqasm.program",
      "supportedOperations": [
        "ccnot",
        "cnot",
        "cphaseshift",
        "cphaseshift00",
        "cphaseshift01",
        "cphaseshift10",
        "cswap",
        "cy",
        "cz",
        "h",
        "i",
        "iswap",
        "pswap",
        "phaseshift",
        "rx",
        "ry",
        "rz",
        "s",
        "si",
        "swap",
        "t",
        "ti",
        "v",
        "vi",
        "x",
        "xx",
        "xy",
        "y",
        "yy",
        "z",
        "zz"
      ],
      "supportedPragmas": [
        "braket_unitary_matrix"
      ],
      "forbiddenPragmas": [],
      "maximumQubitArrays": 1,
      "maximumClassicalArrays": 1,
      "forbiddenArrayOperations": [
        "concatenation",
        "negativeIndex",
        "range",
        "rangeWithStep",
        "slicing",
        "selection"
      ],
      "requiresAllQubitsMeasurement": true,
      "supportsPhysicalQubits": false,
      "requiresContiguousQubitIndices": true,
      "disabledQubitRewiringSupported": false,
      "supportedResultTypes": [
        {
          "name": "Sample",
          "observables": [
            "x",
            "y",
            "z",
            "h",
            "i",
            "hermitian"
          ],
          "minShots": 1,
          "maxShots": 100000
        },
        {
          "name": "Expectation",
          "observables": [
            "x",
            "y",
            "z",
            "h",
            "i",
            "hermitian"
          ],
          "minShots": 0,
          "maxShots": 100000
        },
        {
          "name": "Variance",
          "observables": [
            "x",
            "y",
            "z",
            "h",
            "i",
            "hermitian"
          ],
          "minShots": 0,
          "maxShots": 100000
        },
        {
          "name": "Probability",
          "minShots": 1,
          "maxShots": 100000
        },
        {
          "name": "Amplitude",
          "minShots": 0,
          "maxShots": 0
        }
        {
          "name": "AdjointGradient",
          "minShots": 0,
          "maxShots": 0
        }
      ]
    }
  },
...
```

# Simulasikan kebisingan dengan OpenQASM 3.0
Simulasikan kebisingan

Untuk mensimulasikan noise dengan OpenQASM3, Anda menggunakan instruksi *pragma* untuk menambahkan operator noise. Misalnya, untuk mensimulasikan versi bising dari [program GHZ yang disediakan sebelumnya, Anda dapat mengirimkan program](braket-openqasm-create-submit-task.md#braket-openqasm-example-program) OpenQASM berikut.

```
// ghz.qasm
// Prepare a GHZ state
OPENQASM 3;

qubit[3] q;
bit[3] c;

h q[0];
#pragma braket noise depolarizing(0.75) q[0] cnot q[0], q[1];
#pragma braket noise depolarizing(0.75) q[0]
#pragma braket noise depolarizing(0.75) q[1] cnot q[1], q[2];
#pragma braket noise depolarizing(0.75) q[0]
#pragma braket noise depolarizing(0.75) q[1]

c = measure q;
```

Spesifikasi untuk semua operator kebisingan pragma yang didukung disediakan dalam daftar berikut.

```
#pragma braket noise bit_flip(<float in [0,1/2]>) <qubit>
#pragma braket noise phase_flip(<float in [0,1/2]>) <qubit>
#pragma braket noise pauli_channel(<float>, <float>, <float>)  <qubit>
#pragma braket noise depolarizing(<float in [0,3/4]>) <qubit>
#pragma braket noise two_qubit_depolarizing(<float in [0,15/16]>) <qubit>, <qubit>
#pragma braket noise two_qubit_dephasing(<float in [0,3/4]>) <qubit>, <qubit>
#pragma braket noise amplitude_damping(<float in [0,1]>) <qubit>
#pragma braket noise generalized_amplitude_damping(<float in [0,1]> <float in [0,1]>)  <qubit>
#pragma braket noise phase_damping(<float in [0,1]>) <qubit>
#pragma braket noise kraus([[<complex m0_00>, ], ...], [[<complex m1_00>, ], ...], ...) <qubit>[, <qubit>]     // maximum of 2 qubits and maximum of 4 matrices for 1 qubit, 16 for 2
```

## Operator Kraus


Untuk menghasilkan operator Kraus, Anda dapat mengulangi melalui daftar matriks, mencetak setiap elemen matriks sebagai ekspresi kompleks.

Saat menggunakan operator Kraus, ingat hal berikut:
+ Jumlah tidak qubits boleh melebihi 2. [Definisi saat ini dalam skema](https://github.com/aws/amazon-braket-sdk-python/blob/0d28a8fa89263daf5d88bc706e79200d8dc091a8/src/braket/circuits/noises.py#L811-L814)) menetapkan batas ini.
+ Panjang daftar argumen harus kelipatan 8. Ini berarti harus terdiri hanya dari matriks 2x2.
+ Panjang total tidak melebihi 2 matriks num\$1qubits 2\$1. Ini berarti 4 matriks untuk 1 qubit dan 16 untuk 2. qubits
+ Semua matriks yang disediakan [benar-benar pelestarian jejak positif (CPTP)](https://github.com/aws/amazon-braket-sdk-python/blob/0d28a8fa89263daf5d88bc706e79200d8dc091a8/src/braket/circuits/quantum_operator_helpers.py#L94-L108).
+ Produk operator Kraus dengan konjugat transpos mereka perlu ditambahkan ke matriks identitas.

# Qubitrewiring dengan OpenQASM 3.0
Qubitpengkabelan ulang

[Amazon Braket mendukung qubit notasi fisik dalam OpenQASM pada Rigetti perangkat (untuk mempelajari lebih lanjut lihat halaman ini).](https://github.com/openqasm/openqasm/blob/main/source/language/types.rst) Saat menggunakan fisik qubits dengan [strategi rewiring naif](https://pyquil-docs.rigetti.com/en/v2.28.1/compiler.html#naive), pastikan qubits terhubung pada perangkat yang dipilih. Atau, jika qubit register digunakan sebagai gantinya, strategi rewiring PARAL diaktifkan secara default pada Rigetti perangkat.

```
// ghz.qasm
// Prepare a GHZ state
OPENQASM 3;

h $0;
cnot $0, $1;
cnot $1, $2;

measure $0;
measure $1;
measure $2;
```

# Kompilasi verbatim dengan OpenQASM 3.0
Kompilasi kata demi kata

Ketika Anda menjalankan sirkuit kuantum pada komputer kuantum yang disediakan oleh vendor sepertiRigetti, danIonQ, Anda dapat mengarahkan kompiler untuk menjalankan sirkuit Anda persis seperti yang ditentukan, tanpa modifikasi apa pun. Fitur ini dikenal sebagai kompilasi *verbatim*. Dengan perangkat Rigetti, Anda dapat menentukan dengan tepat apa yang akan dipertahankan - baik seluruh sirkuit atau hanya bagian tertentu saja. Untuk melestarikan hanya bagian tertentu dari sirkuit, Anda harus menggunakan gerbang asli di dalam wilayah yang diawetkan. Saat ini, IonQ hanya mendukung kompilasi kata demi kata untuk seluruh rangkaian, sehingga setiap instruksi di sirkuit perlu dilampirkan dalam kotak kata demi kata.

Dengan OpenQASM, Anda dapat secara eksplisit menentukan pragma kata demi kata di sekitar kotak kode yang kemudian dibiarkan tidak tersentuh dan tidak dioptimalkan oleh rutin kompilasi tingkat rendah perangkat keras. Contoh kode berikut menunjukkan cara menggunakan `#pragma braket verbatim` direktif untuk mencapai hal ini.

```
OPENQASM 3;

bit[2] c;

#pragma braket verbatim
box{
    rx(0.314159) $0;
    rz(0.628318) $0, $1;
    cz $0, $1;
}

c[0] = measure $0;
c[1] = measure $1;
```

Untuk informasi lebih rinci tentang proses kompilasi kata demi kata, termasuk contoh dan praktik terbaik, lihat contoh notebook kompilasi [Verbatim yang tersedia di repositori github](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Verbatim_Compilation.ipynb). amazon-braket-examples

## Konsol Braket


Tugas OpenQASM 3.0 tersedia dan dapat dikelola dalam konsol Amazon Braket. Di konsol, Anda memiliki pengalaman yang sama mengirimkan tugas kuantum di OpenQASM 3.0 seperti yang Anda kirimkan tugas kuantum yang ada.

## Sumber daya tambahan


OpenQASM tersedia di semua Wilayah Amazon Braket.

[Untuk contoh notebook untuk memulai dengan OpenQASM di Amazon Braket, lihat Tutorial Braket. GitHub](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Getting_Started_with_OpenQASM_on_Braket.ipynb)

# Gradien komputasi dengan OpenQASM 3.0
Gradien komputasi

Amazon Braket mendukung perhitungan gradien pada simulator on-demand dan lokal saat berjalan dalam mode (tepat). `shots=0` Ini dicapai melalui penggunaan metode diferensiasi adjoint. Untuk menentukan gradien yang ingin Anda hitung, Anda dapat memberikan pragma yang sesuai, seperti yang ditunjukkan dalam kode dalam contoh berikut.

```
OPENQASM 3.0;
input float alpha;

bit[2] b;
qubit[2] q;

h q[0];
h q[1];
rx(alpha) q[0];
rx(alpha) q[1];
b[0] = measure q[0];
b[1] = measure q[1];

#pragma braket result adjoint_gradient h(q[0]) @ i(q[1]) alpha
```

Alih-alih mencantumkan semua parameter individual secara eksplisit, Anda juga dapat menentukan `all` kata kunci dalam pragma. Ini akan menghitung gradien sehubungan dengan semua `input` parameter yang tercantum, yang dapat menjadi pilihan yang nyaman ketika jumlah parameter sangat besar. Dalam hal ini, pragma akan terlihat seperti kode dalam contoh berikut.

```
#pragma braket result adjoint_gradient h(q[0]) @ i(q[1]) all
```

Semua tipe yang dapat diamati didukung dalam implementasi OpenQASM 3.0 Amazon Braket, termasuk operator individual, produk tensor, observable Hermitian, dan observable. `Sum` Operator spesifik yang ingin Anda gunakan saat menghitung gradien harus dibungkus dalam `expectation()` fungsi, dan qubit yang ditindaklanjuti oleh setiap suku yang dapat diamati harus ditentukan secara eksplisit.

# Mengukur qubit tertentu dengan OpenQASM 3.0
Mengukur qubit tertentu

Simulator vektor keadaan lokal dan simulator matriks kepadatan lokal yang disediakan oleh Amazon Braket mendukung pengajuan OpenQASM program di mana subset qubit sirkuit dapat diukur secara selektif. Kemampuan ini, sering disebut sebagai pengukuran paral, memungkinkan perhitungan kuantum yang lebih bertarget dan efisien. Misalnya, dalam cuplikan kode berikut, Anda dapat membuat sirkuit dua-qubit dan memilih untuk hanya mengukur qubit pertama, sambil membiarkan qubit kedua tidak terukur.

```
partial_measure_qasm = """
OPENQASM 3.0;
bit[1] b;
qubit[2] q;
h q[0];
cnot q[0], q[1];
b[0] = measure q[0];
"""
```

Dalam contoh ini, kita memiliki sirkuit kuantum dengan dua qubit`q[1]`, `q[0]` dan, tetapi kita hanya tertarik untuk mengukur keadaan qubit pertama. Ini dicapai oleh garis`b[0] = measure q[0]`, yang mengukur keadaan qubit [0] dan menyimpan hasilnya dalam bit klasik b [0]. Untuk menjalankan skenario pengukuran sebagian ini, kita dapat menjalankan kode berikut pada simulator vektor status lokal yang disediakan oleh Amazon Braket.

```
from braket.devices import LocalSimulator

local_sim = LocalSimulator()
partial_measure_local_sim_task = local_sim.run(OpenQASMProgram(source=partial_measure_qasm), shots = 10)
partial_measure_local_sim_result = partial_measure_local_sim_task.result()
print(partial_measure_local_sim_result.measurement_counts)
print("Measured qubits: ", partial_measure_local_sim_result.measured_qubits)
```

Anda dapat memeriksa apakah perangkat mendukung pengukuran sebagian dengan memeriksa `requiresAllQubitsMeasurement` bidang di properti tindakannya; jika ya`False`, maka pengukuran paral didukung.

```
from braket.devices import Devices
            
AwsDevice(Devices.Rigetti.Ankaa3).properties.action['braket.ir.openqasm.program'].requiresAllQubitsMeasurement
```

Di sini, `requiresAllQubitsMeasurement` adalah`False`, yang menunjukkan bahwa tidak semua qubit harus diukur.

# Jelajahi Kemampuan Eksperimental
(Lanjutan) Jelajahi Kemampuan Eksperimental

Kemampuan eksperimental menyediakan akses ke perangkat keras dengan ketersediaan terbatas dan fitur perangkat lunak baru yang muncul. Fitur-fitur ini dapat memengaruhi kinerja perangkat di luar spesifikasi standar. Anda dapat secara otomatis mengaktifkan kemampuan perangkat lunak eksperimental berdasarkan per tugas melalui Amazon Braket SDK.

Untuk menggunakan kemampuan eksperimental, tentukan `experimental_capabilities` parameter saat Anda membuat tugas kuantum. Tetapkan parameter ini `"ALL"` untuk mengaktifkan semua fitur eksperimental yang tersedia untuk tugas itu. Contoh berikut menunjukkan cara mengaktifkan kemampuan eksperimental saat Anda menjalankan sirkuit pada perangkat:

```
from braket.aws import AwsDevice

device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila")

task = device.run(
   circuit,
   shots=1000,
   experimental_capabilities="ALL"
)
```

**catatan**  
Fitur-fitur ini bersifat eksperimental dan dapat berubah tanpa pemberitahuan. Kinerja perangkat mungkin berbeda dari spesifikasi yang dipublikasikan, dan hasilnya mungkin berbeda dari operasi standar. Anda harus secara eksplisit mengaktifkan kemampuan eksperimental untuk setiap tugas. Tugas tanpa parameter ini hanya akan menggunakan kemampuan perangkat standar.

**Topics**
+ [

## Akses ke detuning lokal di Aquila QuEra
](#braket-access-local-detuning)
+ [

## Akses ke geometri tinggi di Aquila QuEra
](#braket-access-tall-geometries)
+ [

## Akses ke geometri ketat di Aquila QuEra
](#braket-access-tight-geometries)
+ [

## Sirkuit dinamis pada perangkat IQM
](#braket-access-dynamic-circuits)

## Akses ke detuning lokal di Aquila QuEra


Detuning lokal (LD) adalah bidang kontrol baru yang bergantung pada waktu dengan pola spasial yang dapat disesuaikan. Bidang LD memengaruhi qubit sesuai dengan pola spasial yang dapat disesuaikan, mewujudkan Hamiltonian yang berbeda untuk qubit yang berbeda di luar apa yang dapat dibuat oleh medan mengemudi seragam dan interaksi Rydberg-Rydberg.

**Kendala:**

Pola spasial bidang detuning lokal dapat disesuaikan untuk setiap program AHS, tetapi konstan selama program. Deret waktu bidang detuning lokal harus dimulai dan diakhiri pada nol dengan semua nilai kurang dari atau sama dengan nol. Selain itu, parameter bidang detuning lokal dibatasi oleh batasan numerik, yang dapat dilihat melalui Braket SDK di bagian properti perangkat tertentu -. `aquila_device.properties.paradigm.rydberg.rydbergLocal`

**Keterbatasan:**

Saat menjalankan program kuantum yang menggunakan bidang detuning lokal (bahkan jika besarnya diatur ke nol konstan di Hamiltonian), perangkat mengalami dekoherensi yang lebih cepat daripada waktu T2 yang tercantum di bagian kinerja properti Aquila. Jika tidak perlu, praktik terbaik adalah menghilangkan bidang detuning lokal dari program Hamiltonian AHS.

![\[Simulasi hamiltonian analog dalam terminologi spin, di mana ada qubit, medan penggerak global yang bergantung pada waktu, dan detuning lokal yang bergantung pada waktu.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/AHS_spin_terminology.png)


**Contoh:**

1. **Mensimulasikan efek medan magnet longitudinal yang tidak seragam dalam sistem putaran**

   Sementara amplitudo dan fase medan penggerak memiliki efek yang sama pada qubit seperti medan magnet transversal pada putaran, jumlah detuning medan penggerak dan detuning lokal menghasilkan efek yang sama pada qubit seperti medan longitudinal pada putaran. Dengan kontrol spasial atas bidang detuning lokal, sistem putaran yang lebih kompleks dapat disimulasikan.

1. **Mempersiapkan keadaan awal non-ekuilibrium**

   Contoh notebook [Simulasi teori pengukur kisi dengan atom Rydberg menunjukkan bagaimana menekan atom](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/analog_hamiltonian_simulation/07_Simulating_Lattice_Gauge_Theory_with_Rydberg_Atoms.ipynb) pusat dari susunan linier 9 atom agar tidak tereksitasi saat menganil sistem menuju fase terurut Z2. Setelah langkah persiapan, bidang detuning lokal diturunkan, dan program AHS terus mensimulasikan evolusi waktu sistem mulai dari keadaan non-ekuilibrium khusus ini.

1. **Memecahkan masalah optimasi tertimbang**

   Contoh notebook [Maximum weight independent set](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/analog_hamiltonian_simulation/08_Maximum_Weight_Independent_Set.ipynb) (MWIS) menunjukkan cara memecahkan masalah MWIS di Aquila. Bidang detuning lokal digunakan untuk menentukan bobot pada node grafik unit disk, yang ujung-ujungnya direalisasikan oleh efek penyumbatan Rybderg. Mulai dari keadaan dasar yang seragam, dan secara bertahap meningkatkan bidang detuning lokal membuat transisi sistem ke keadaan dasar MWIS Hamiltonian untuk menemukan solusi untuk masalah tersebut.

## Akses ke geometri tinggi di Aquila QuEra


Fitur geometri tinggi memungkinkan Anda menentukan geometri dengan ketinggian yang meningkat. Dengan kemampuan ini, pengaturan atom program AHS Anda dapat menjangkau panjang tambahan ke arah y di luar kemampuan reguler Aquila.

**Kendala:**

Tinggi maksimal untuk geometri tinggi adalah 0,000128 m (128 um).

**Keterbatasan:**

Ketika kemampuan eksperimental ini diaktifkan untuk akun Anda, kemampuan yang ditampilkan di halaman properti perangkat dan `GetDevice` panggilan akan terus mencerminkan batas bawah reguler pada ketinggian. Ketika program AHS menggunakan pengaturan atom yang melampaui kemampuan reguler, kesalahan pengisian diperkirakan akan meningkat. Anda akan menemukan peningkatan jumlah 0 yang tidak terduga di `pre_sequence` bagian hasil tugas, pada gilirannya, menurunkan kesempatan untuk mendapatkan pengaturan yang diinisialisasi dengan sempurna. Efek ini paling kuat dalam baris dengan banyak atom.

![\[Grafik tiga titik menunjukkan penggambaran geometri tinggi dalam bentuk garis 1d, tangga, dan multipleks.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/tall-geometry-graphs.PNG)


**Contoh:**

1. **Pengaturan 1d dan kuasi-1d yang lebih besar**

   Rantai atom dan susunan seperti tangga dapat diperluas ke nomor atom yang lebih tinggi. Dengan mengorientasikan long direction parallel ke y memungkinkan pemrograman instance yang lebih lama dari model-model ini.

1. **Lebih banyak ruang untuk multiplexing pelaksanaan tugas dengan geometri kecil**

   Contoh notebook [Tugas kuantum paralel di Aquila](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/analog_hamiltonian_simulation/03_Parallel_tasks_on_Aquila.ipynb) menunjukkan cara memaksimalkan area yang tersedia: dengan menempatkan salinan geometri multipleks yang dimaksud dalam satu susunan atom. Dengan area yang lebih tersedia, lebih banyak salinan dapat ditempatkan.

## Akses ke geometri ketat di Aquila QuEra


Fitur geometri ketat memungkinkan Anda menentukan geometri dengan jarak yang lebih pendek di antara baris tetangga. Dalam program AHS, atom disusun dalam baris, dipisahkan oleh jarak vertikal minimal. Koordinat y dari dua situs atom harus nol (baris yang sama), atau berbeda lebih dari jarak baris minimal (baris berbeda). Dengan kemampuan geometri yang ketat, jarak baris minimal berkurang, memungkinkan terciptanya susunan atom yang lebih ketat. Sementara ekstensi ini tidak mengubah persyaratan jarak Euclidean minimal antara atom, ini memungkinkan penciptaan kisi di mana atom jauh menempati baris tetangga lebih dekat satu sama lain, contoh penting adalah kisi segitiga.

**Kendala:**

Jarak baris minimal untuk geometri ketat adalah 0,000002 m (2 um).

**Keterbatasan:**

Ketika kemampuan eksperimental ini diaktifkan untuk akun Anda, kemampuan yang ditampilkan di halaman properti perangkat dan `GetDevice` panggilan akan terus mencerminkan batas bawah reguler pada ketinggian. Ketika program AHS menggunakan pengaturan atom yang melampaui kemampuan reguler, kesalahan pengisian diperkirakan akan meningkat. Pelanggan akan menemukan peningkatan jumlah 0 yang tidak terduga di `pre_sequence` bagian hasil tugas, pada gilirannya, menurunkan kesempatan untuk mendapatkan pengaturan yang diinisialisasi dengan sempurna. Efek ini paling kuat dalam baris dengan banyak atom.

![\[Grafik menunjukkan geometri ketat dari kisi segitiga titik-titik di sebelah kiri dan grafik kanan adalah kisi heksagonal titik-titik.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/tight-geometry-graphs.PNG)


**Contoh:**

1. **Kisi non-persegi panjang dengan konstanta kisi kecil**

   Jarak baris yang lebih ketat memungkinkan terciptanya kisi di mana tetangga terdekat dengan beberapa atom berada dalam arah diagonal. Contoh penting adalah kisi segitiga, heksagonal, dan Kagome dan beberapa kristal semu.

1. **Keluarga kisi yang dapat disetel**

   Dalam program AHS, interaksi disetel dengan menyesuaikan jarak antara pasangan atom. Jarak baris yang lebih ketat memungkinkan penyetelan interaksi pasangan atom yang berbeda relatif satu sama lain dengan lebih banyak kebebasan, karena sudut dan jarak yang menentukan struktur atom kurang dibatasi oleh batasan jarak baris minimal. Contoh penting adalah keluarga kisi Shastry-Sutherland dengan panjang ikatan yang berbeda.

## Sirkuit dinamis pada perangkat IQM


Sirkuit dinamis pada IQM perangkat memungkinkan pengukuran sirkuit tengah (MCM) dan operasi feed-forward. Fitur-fitur ini memungkinkan peneliti dan pengembang kuantum untuk menerapkan algoritma kuantum canggih dengan logika bersyarat dan kemampuan penggunaan kembali qubit. Fitur eksperimental ini membantu mengeksplorasi algoritma kuantum dengan peningkatan efisiensi sumber daya dan mempelajari mitigasi kesalahan kuantum dan skema koreksi kesalahan.

**Instruksi kunci:**
+ `measure_ff`: Menerapkan pengukuran untuk kontrol feed-forward, mengukur qubit dan menyimpan hasilnya dengan kunci umpan balik.
+ `cc_prx`: Menerapkan rotasi yang dikontrol secara klasik yang hanya berlaku ketika hasil yang terkait dengan kunci umpan balik yang diberikan mengukur status \$11⟩.

Amazon Braket mendukung sirkuit dinamis melaluiOpenQASM,Amazon Braket SDK, dan. Amazon Braket Qiskit Provider

**Kendala:**

1. Kunci umpan balik dalam `measure_ff` instruksi harus unik.

1. A `cc_prx` harus terjadi setelah `measure_ff` dengan kunci umpan balik yang sama.

1. Dalam satu rangkaian, feed-forward pada qubit hanya dapat dikontrol oleh satu qubit, baik dengan sendirinya atau oleh qubit lain. Di sirkuit yang berbeda, Anda dapat memiliki pasangan kontrol yang berbeda.<a name="lower"></a>

   1. Misalnya, jika qubit 1 dikendalikan oleh qubit 2, qubit tidak dapat dikontrol oleh qubit 3 di sirkuit yang sama. Tidak ada batasan pada berapa kali kontrol diterapkan antara qubit 1 dan qubit 2. Qubit 2 dapat dikontrol oleh qubit 3 (atau qubit 1), kecuali jika reset aktif dilakukan pada qubit 2. 

1. Kontrol hanya dapat diterapkan ke qubit dalam grup yang sama. Grup qubit untuk IQM Garnet dan Emerald perangkat ada dalam gambar berikut. 

1. Program dengan kemampuan ini harus diserahkan sebagai program kata demi kata. Untuk mempelajari lebih lanjut tentang program kata demi kata, lihat Kompilasi kata demi [kata dengan OpenQASM 3.0](https://docs.aws.amazon.com/braket/latest/developerguide/braket-openqasm-verbatim-compilation.html).

**Keterbatasan:**

MCM hanya dapat digunakan untuk kontrol feed-forward dalam suatu program. Hasil MCM (0 atau 1) tidak dikembalikan sebagai bagian dari hasil tugas.

![\[Gambar kiri adalah perangkat 20-qubit IQM Garnet dengan 2 grup qubit dalam kisi persegi, dan gambar kanan adalah perangkat IQM Emerald 54-qubit dengan 4 grup qubit dalam kisi persegi.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/IQM-Garnet-Emerald-qubit-grouping.png)


Gambar-gambar ini menampilkan pengelompokan qubit untuk kedua IQM perangkat. Perangkat Garnet 20-qubit berisi 2 grup qubit, sedangkan perangkat Emerald 54-qubit berisi 4 grup qubit. 

**Contoh:**

1. **Qubit digunakan kembali melalui reset aktif**

   MCM dengan operasi reset bersyarat memungkinkan penggunaan kembali qubit dalam satu eksekusi sirkuit. Ini mengurangi persyaratan kedalaman sirkuit dan meningkatkan pemanfaatan sumber daya perangkat kuantum.

1. **Perlindungan flip bit aktif**

   Sirkuit dinamis mendeteksi kesalahan bit flip dan menerapkan operasi korektif berdasarkan hasil pengukuran. Implementasi ini berfungsi sebagai eksperimen deteksi kesalahan kuantum.

1. **Eksperimen teleportasi**

   Teleportasi negara mentransfer status qubit menggunakan operasi kuantum lokal dan informasi klasik dari. MCMs Teleportasi gerbang mengimplementasikan gerbang antara qubit tanpa operasi kuantum langsung. Eksperimen ini menunjukkan subrutin dasar dalam tiga bidang utama: koreksi kesalahan kuantum, komputasi kuantum berbasis pengukuran, dan komunikasi kuantum.

1. **Simulasi sistem kuantum terbuka**

   Sirkuit dinamis memodelkan kebisingan dalam sistem kuantum melalui qubit data dan keterikatan lingkungan, dan pengukuran lingkungan. Pendekatan ini menggunakan qubit spesifik untuk mewakili elemen data dan lingkungan. Saluran Kebisingan dapat dirancang oleh gerbang dan pengukuran yang diterapkan pada lingkungan.

Untuk informasi selengkapnya tentang penggunaan sirkuit dinamis, lihat contoh tambahan di repositori [notebook Amazon Braket](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/experimental_capabilities/dynamic_circuits).

# Kontrol pulsa pada Amazon Braket
(Lanjutan) Kontrol pulsa pada Amazon Braket

Pulsa adalah sinyal analog yang mengontrol qubit di komputer kuantum. Dengan perangkat tertentu di Amazon Braket, Anda dapat mengakses fitur kontrol pulsa untuk mengirimkan sirkuit menggunakan pulsa. Anda dapat mengakses kontrol pulsa melalui Braket SDK, menggunakan OpenQASM 3.0, atau langsung melalui Braket. APIs Pertama, perkenalkan beberapa konsep kunci untuk kontrol pulsa di Braket.

**Topics**
+ [

## Bingkai
](#braket-frame)
+ [

## Port
](#braket-port)
+ [

## Bentuk gelombang
](#braket-waveform)
+ [

# Bekerja dengan Hello Pulse
](braket-hello-pulse.md)
+ [

# Mengakses gerbang asli menggunakan pulsa
](braket-native-gate-pulse.md)

## Bingkai


Bingkai adalah abstraksi perangkat lunak yang bertindak sebagai jam dalam program kuantum dan fase. Waktu jam bertambah pada setiap penggunaan dan sinyal pembawa stateful yang ditentukan oleh frekuensi. Saat mentransmisikan sinyal ke qubit, bingkai menentukan frekuensi pembawa qubit, offset fase, dan waktu di mana amplop bentuk gelombang dipancarkan. Dalam Braket Pulse, membangun frame tergantung pada perangkat, frekuensi, dan fase. Bergantung pada perangkat, Anda dapat memilih bingkai yang telah ditentukan atau membuat instance frame baru dengan menyediakan port.

```
from braket.aws import AwsDevice
from braket.pulse import Frame, Port

# Predefined frame from a device
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
drive_frame = device.frames["Transmon_5_charge_tx"]

# Create a custom frame
readout_frame = Frame(frame_id="r0_measure", port=Port("channel_0", dt=1e-9), frequency=5e9, phase=0)
```

## Port


Port adalah abstraksi perangkat lunak yang mewakili komponen perangkat input/output keras apa pun yang mengendalikan qubit. Ini membantu vendor perangkat keras menyediakan antarmuka yang dengannya pengguna dapat berinteraksi untuk memanipulasi dan mengamati qubit. Port dicirikan oleh string tunggal yang mewakili nama konektor. String ini juga memperlihatkan kenaikan waktu minimum yang menentukan seberapa halus kita dapat mendefinisikan bentuk gelombang.

```
from braket.pulse import Port

Port0 = Port("channel_0", dt=1e-9)
```

## Bentuk gelombang


Bentuk gelombang adalah amplop yang bergantung pada waktu yang dapat kita gunakan untuk memancarkan sinyal pada port output atau menangkap sinyal melalui port input. Anda dapat menentukan bentuk gelombang Anda secara langsung baik melalui daftar bilangan kompleks atau dengan menggunakan templat bentuk gelombang untuk menghasilkan daftar dari penyedia perangkat keras.

```
from braket.pulse import ArbitraryWaveform, ConstantWaveform
import numpy as np

cst_wfm = ConstantWaveform(length=1e-7, iq=0.1)
arb_wf = ArbitraryWaveform(amplitudes=np.linspace(0, 100))
```

 Braket Pulse menyediakan perpustakaan standar bentuk gelombang, termasuk bentuk gelombang konstan, bentuk gelombang Gaussian, dan bentuk gelombang Penghapusan Derivatif oleh Gerbang Adiabatik (DRAG). Anda dapat mengambil data bentuk gelombang melalui `sample` fungsi untuk menggambar bentuk bentuk gelombang seperti yang ditunjukkan pada contoh berikut.

```
from braket.pulse import GaussianWaveform
import numpy as np
import matplotlib.pyplot as plt

zero_at_edge1 = GaussianWaveform(1e-7, 25e-9, 0.1, True)
# or zero_at_edge1 = GaussianWaveform(1e-7, 25e-9, 0.1)
zero_at_edge2 = GaussianWaveform(1e-7, 25e-9, 0.1, False)

times_1 = np.arange(0, zero_at_edge1.length, drive_frame.port.dt)
times_2 = np.arange(0, zero_at_edge2.length, drive_frame.port.dt)

plt.plot(times_1, zero_at_edge1.sample(drive_frame.port.dt))
plt.plot(times_2, zero_at_edge2.sample(drive_frame.port.dt))
```

![\[Grafik yang menunjukkan amplitudo dari waktu ke waktu untuk dua kasus: ZaE = Benar (kurva bawah) dan ZaE = Salah (kurva atas). Kurva memiliki bentuk lonceng memuncak sekitar 0,5 detik dengan amplitudo 0,10 a. u..\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/gaussianwaveform.png)


Gambar sebelumnya menggambarkan bentuk gelombang Gaussian yang dibuat dari. `GaussianWaveform` Kami memilih panjang pulsa 100 ns, lebar 25 ns, dan amplitudo 0,1 (unit arbitrer). Bentuk gelombang berpusat di jendela pulsa. `GaussianWaveform`menerima argumen boolean `zero_at_edges` (ZaE dalam legenda). Ketika diatur ke`True`, argumen ini mengimbangi bentuk gelombang Gaussian sedemikian rupa sehingga titik pada t=0 dan t= `length` berada pada nol dan mengubah skala amplitudonya sedemikian rupa sehingga nilai maksimum sesuai dengan argumen. `amplitude`

# Bekerja dengan Hello Pulse


Pada bagian ini, Anda akan belajar cara mengkarakterisasi dan membangun gerbang qubit tunggal secara langsung menggunakan pulsa pada perangkat. Rigetti Menerapkan medan elektromagnetik ke qubit mengarah ke osilasi Rabi, mengalihkan qubit antara keadaan 0 dan 1. Dengan panjang dan fase pulsa yang dikalibrasi, osilasi Rabi dapat menghitung gerbang qubit tunggal. Di sini, kita akan menentukan panjang pulsa optimal untuk mengukur pulsa pi/2, blok dasar yang digunakan untuk membangun urutan pulsa yang lebih kompleks.

Pertama, untuk membangun urutan pulsa, impor `PulseSequence` kelas.

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

Selanjutnya, buat instance perangkat Braket baru menggunakan (Amazon Resource NameARN) QPU. Blok kode berikut menggunakanRigetti Ankaa-3.

```
device = AwsDevice(Devices.Rigetti.Ankaa3)
```

Urutan pulsa berikut mencakup dua komponen: Memainkan bentuk gelombang dan mengukur qubit. Urutan pulsa biasanya dapat diterapkan pada bingkai. Dengan beberapa pengecualian seperti penghalang dan penundaan, yang dapat diterapkan pada qubit. Sebelum membangun urutan pulsa Anda harus mengambil frame yang tersedia. Bingkai drive digunakan untuk menerapkan pulsa untuk osilasi Rabi, dan bingkai pembacaan untuk mengukur status qubit. Contoh ini, menggunakan frame qubit 25.

```
drive_frame = device.frames["Transmon_25_charge_tx"]
readout_frame = device.frames["Transmon_25_readout_rx"]
```

Sekarang, buat bentuk gelombang yang akan diputar di bingkai drive. Tujuannya adalah untuk mengkarakterisasi perilaku qubit untuk panjang pulsa yang berbeda. Anda akan memainkan bentuk gelombang dengan panjang yang berbeda setiap kali. Alih-alih membuat instance bentuk gelombang baru setiap kali, gunakan Rem `FreeParameter` yang didukung dalam urutan pulsa. Anda dapat membuat bentuk gelombang dan urutan pulsa sekali dengan parameter bebas, dan kemudian menjalankan urutan pulsa yang sama dengan nilai input yang berbeda. 

```
waveform = GaussianWaveform(FreeParameter("length"), FreeParameter("length") * 0.25, 0.2, False)
```

Akhirnya, satukan mereka sebagai urutan pulsa. Dalam urutan pulsa, `play` putar bentuk gelombang yang ditentukan pada bingkai drive, dan `capture_v0` mengukur status dari bingkai pembacaan.

```
pulse_sequence = (
    PulseSequence()
    .play(drive_frame, waveform)
    .capture_v0(readout_frame)
)
```

Pindai berbagai panjang pulsa dan kirimkan ke QPU. Sebelum menjalankan urutan pulsa pada QPU, ikat nilai parameter bebas.

```
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
]
```

Statistik pengukuran qubit menunjukkan dinamika osilasi qubit yang berosilasi antara keadaan 0 dan keadaan 1. Dari data pengukuran, Anda dapat mengekstrak frekuensi Rabi dan menyempurnakan panjang pulsa untuk mengimplementasikan gerbang 1-qubit tertentu. Misalnya, dari data pada gambar di bawah ini, periodisitasnya sekitar 154 ns. Jadi gerbang rotasi pi/2 akan sesuai dengan urutan pulsa dengan panjang = 38.5ns. 

![\[Grafik garis yang menunjukkan jumlah populasi dengan durasi pulsa dalam hitungan detik. Ada dua puncak dan satu palung dalam grafik.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/Rabi-frequency.png)


## Halo Pulse menggunakan OpenPulse


 [OpenPulse](https://openqasm.com/language/openpulse.html)adalah bahasa untuk menentukan kontrol tingkat pulsa dari perangkat kuantum umum dan merupakan bagian dari spesifikasi OpenQASM 3.0. Amazon Braket mendukung OpenPulse pulsa pemrograman langsung menggunakan representasi OpenQASM 3.0.

 Braket digunakan OpenPulse sebagai representasi perantara yang mendasari untuk mengekspresikan pulsa dalam instruksi asli. OpenPulsemendukung penambahan kalibrasi instruksi dalam bentuk deklarasi `defcal` (kependekan dari “define calibration”). Dengan deklarasi ini, Anda dapat menentukan implementasi instruksi gerbang dalam tata bahasa kontrol tingkat rendah.

Anda dapat melihat OpenPulse program Braket `PulseSequence` menggunakan perintah berikut.

```
print(pulse_sequence.to_ir())
```

Anda juga dapat membuat OpenPulse program secara langsung.

```
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);
}
"""
```

Buat `Program` objek dengan skrip Anda. Kemudian, kirimkan program ke 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)
```

# Mengakses gerbang asli menggunakan pulsa


Para peneliti sering perlu tahu persis bagaimana gerbang *asli* yang didukung oleh QPU tertentu diimplementasikan sebagai pulsa. Urutan pulsa dikalibrasi dengan hati-hati oleh penyedia perangkat keras, tetapi mengaksesnya memberi peneliti kesempatan untuk merancang gerbang yang lebih baik atau mengeksplorasi protokol untuk mitigasi kesalahan seperti ekstrapolasi nol kebisingan dengan meregangkan pulsa gerbang tertentu.

Amazon Braket mendukung akses terprogram ke gerbang asli dari Rigetti.

```
import math
from braket.aws import AwsDevice
from braket.circuits import Circuit, GateCalibrations, QubitSet
from braket.circuits.gates import Rx

device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")

calibrations = device.gate_calibrations
print(f"Downloaded {len(calibrations)} calibrations.")
```

**catatan**  
Penyedia perangkat keras secara berkala mengkalibrasi QPU, seringkali lebih dari sekali sehari. Braket SDK memungkinkan Anda mendapatkan kalibrasi gerbang terbaru.

```
device.refresh_gate_calibrations()
```

Untuk mengambil gerbang asli yang diberikan, seperti gerbang RX atau XY, Anda harus melewati `Gate` objek dan qubit yang diinginkan. Misalnya, Anda dapat memeriksa implementasi pulsa RX (π/2) yang diterapkan pada 0. qubit

```
rx_pi_2_q0 = (Rx(math.pi/2), QubitSet(0))

pulse_sequence_rx_pi_2_q0 = calibrations.pulse_sequences[rx_pi_2_q0]
```

Anda dapat membuat serangkaian kalibrasi yang difilter menggunakan `filter` fungsi tersebut. Anda melewati daftar gerbang atau daftar`QubitSet`. Kode berikut membuat dua set yang berisi semua kalibrasi untuk RX (π/2) dan untuk 0. qubit

```
rx_calibrations = calibrations.filter(gates=[Rx(math.pi/2)])
q0_calibrations = calibrations.filter(qubits=QubitSet([0]))
```

Sekarang Anda dapat memberikan atau memodifikasi aksi gerbang asli dengan melampirkan set kalibrasi khusus. Misalnya, perhatikan rangkaian berikut.

```
bell_circuit = (
    Circuit()
    .rx(0, math.pi/2)
    .rx(1, math.pi/2)
    .iswap(0, 1)
    .rx(1, -math.pi/2)
)
```

Anda dapat menjalankannya dengan kalibrasi gerbang khusus untuk `rx` gerbang `qubit 0` dengan meneruskan kamus `PulseSequence` objek ke argumen `gate_definitions` kata kunci. Anda dapat membuat kamus `pulse_sequences` dari atribut `GateCalibrations` objek. Semua gerbang yang tidak ditentukan diganti dengan kalibrasi pulsa penyedia perangkat keras kuantum.

```
nb_shots = 50
custom_calibration = GateCalibrations({rx_pi_2_q0: pulse_sequence_rx_pi_2_q0})
task = device.run(bell_circuit, gate_definitions=custom_calibration.pulse_sequences, shots=nb_shots)
```

# Simulasi Hamiltonian Analog
(Lanjutan) Simulasi Hamiltonian Analog

[Analog Hamiltonian Simulation](https://en.wikipedia.org/wiki/Hamiltonian_simulation) (AHS) adalah paradigma yang muncul dalam komputasi kuantum yang berbeda secara signifikan dari model sirkuit kuantum tradisional. Alih-alih urutan gerbang, di mana setiap sirkuit hanya bekerja pada beberapa qubit sekaligus. Program AHS didefinisikan oleh parameter yang bergantung pada waktu dan bergantung pada ruang dari Hamiltonian yang bersangkutan. [Hamiltonian dari suatu sistem](https://en.wikipedia.org/wiki/Hamiltonian_(quantum_mechanics)) mengkodekan tingkat energinya dan efek kekuatan eksternal, yang bersama-sama mengatur evolusi waktu dari keadaannya. Untuk sistem N-qubit, Hamiltonian dapat diwakili oleh matriks kuadrat 2 N X2 N dari bilangan kompleks.

Perangkat kuantum yang mampu melakukan AHS dirancang untuk mendekati evolusi waktu sistem kuantum di bawah Hamiltonian khusus dengan menyetel parameter kontrol internalnya secara hati-hati. Seperti, menyesuaikan parameter amplitudo dan detuning dari bidang mengemudi yang koheren. Paradigma AHS sangat cocok untuk mensimulasikan sifat statis dan dinamis sistem kuantum dengan banyak partikel yang berinteraksi, seperti dalam fisika materi terkondensasi atau kimia kuantum. Unit pemrosesan kuantum yang dibangun khusus (QPUs), seperti [perangkat Aquila](https://aws.amazon.com/braket/quantum-computers/quera/) dariQuEra, telah dikembangkan untuk menggunakan kekuatan AHS dan mengatasi masalah di luar jangkauan pendekatan komputasi kuantum digital konvensional dengan cara yang inovatif.

**Topics**
+ [

# Halo AHS: Jalankan Simulasi Hamiltonian Analog pertama Anda
](braket-get-started-hello-ahs.md)
+ [

# Kirim program analog menggunakan QuEra Aquila
](braket-quera-submitting-analog-program-aquila.md)

# Halo AHS: Jalankan Simulasi Hamiltonian Analog pertama Anda


Bagian ini memberikan informasi tentang menjalankan Simulasi Hamiltonian Analog pertama Anda.

**Topics**
+ [

## Rantai spin yang berinteraksi
](#braket-get-started-interacting-spin-chain)
+ [

## Pengaturan
](#braket-get-started-arrangement)
+ [

## Interaksi
](#braket-get-started-interaction)
+ [

## Bidang mengemudi
](#braket-get-started-driving-field)
+ [

## Program AHS
](#braket-get-started-ahs-program)
+ [

## Berjalan di simulator lokal
](#braket-get-started-running-local-simulator)
+ [

## Menganalisis hasil simulator
](#braket-get-started-analyzing-simulator-results)
+ [

## Berjalan di QuEra Aquila QPU
](#braket-get-started-running-aquila-qpu)
+ [

## Menganalisis hasil QPU
](#braket-get-started-analyzing-qpu-results)
+ [

## Langkah selanjutnya
](#braket-get-started-ahs-next)

## Rantai spin yang berinteraksi


Untuk contoh kanonik dari sistem banyak partikel yang berinteraksi, mari kita pertimbangkan cincin delapan putaran (yang masing-masing dapat berada dalam keadaan “naik” dan “bawah”). Meskipun kecil, sistem model ini sudah menunjukkan beberapa fenomena menarik dari bahan magnetik yang terjadi secara alami. Dalam contoh ini, kami akan menunjukkan bagaimana menyiapkan apa yang disebut urutan anti-feromagnetik, di mana putaran berturut-turut mengarah ke arah yang berlawanan.

![\[Diagram menghubungkan 8 simpul lingkaran yang berisi panah terbalik ke atas dan ke bawah.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/AntiFerromagnetic.png)


## Pengaturan


Kita akan menggunakan satu atom netral untuk mewakili setiap putaran, dan status putaran “atas” dan “bawah” akan dikodekan dalam keadaan Rydberg yang tereksitasi dan keadaan dasar atom, masing-masing. Pertama, kami membuat pengaturan 2-d. Kita dapat memprogram cincin putaran di atas dengan kode berikut.

 **Prasyarat**[: Anda perlu menginstal Braket SDK.](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk) (Jika Anda menggunakan instance notebook yang dihosting Braket, SDK ini sudah diinstal sebelumnya dengan notebook.) Untuk mereproduksi plot, Anda juga perlu menginstal matplotlib secara terpisah dengan perintah shell. `pip install matplotlib`

```
from braket.ahs.atom_arrangement import AtomArrangement
import numpy as np
import matplotlib.pyplot as plt  # Required for plotting

a = 5.7e-6  # Nearest-neighbor separation (in meters)

register = AtomArrangement()
register.add(np.array([0.5, 0.5 + 1/np.sqrt(2)]) * a)
register.add(np.array([0.5 + 1/np.sqrt(2), 0.5]) * a)
register.add(np.array([0.5 + 1/np.sqrt(2), - 0.5]) * a)
register.add(np.array([0.5, - 0.5 - 1/np.sqrt(2)]) * a)
register.add(np.array([-0.5, - 0.5 - 1/np.sqrt(2)]) * a)
register.add(np.array([-0.5 - 1/np.sqrt(2), - 0.5]) * a)
register.add(np.array([-0.5 - 1/np.sqrt(2), 0.5]) * a)
register.add(np.array([-0.5, 0.5 + 1/np.sqrt(2)]) * a)
```

yang juga bisa kita rencanakan

```
fig, ax = plt.subplots(1, 1, figsize=(7, 7))
xs, ys = [register.coordinate_list(dim) for dim in (0, 1)]
ax.plot(xs, ys, 'r.', ms=15)

for idx, (x, y) in enumerate(zip(xs, ys)):
    ax.text(x, y, f" {idx}", fontsize=12)

plt.show()  # This will show the plot below in an ipython or jupyter session
```

![\[Plot sebar menunjukkan poin yang didistribusikan di seluruh nilai positif dan negatif pada kedua sumbu.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/PlotNeutralAtoms.png)


## Interaksi


Untuk mempersiapkan fase anti-feromagnetik, kita perlu menginduksi interaksi antara putaran tetangga. Kami menggunakan [interaksi van der Waals](https://en.wikipedia.org/wiki/Van_der_Waals_force) untuk ini, yang secara native diimplementasikan oleh perangkat atom netral (seperti Aquila perangkat dariQuEra). Menggunakan spin-representasi, istilah Hamiltonian untuk interaksi ini dapat dinyatakan sebagai jumlah atas semua pasangan spin (j, k).

![\[Persamaan interaksi Hamilton yang menunjukkan interaksi ini dinyatakan sebagai jumlah atas semua pasangan spin (j, k).\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/HInteraction.png)


Di sini, nj=↑ j ⟨↑ adalah j operator yang mengambil nilai 1 hanya jika spin j berada dalam keadaan “naik”, dan 0 sebaliknya. Kekuatannya adalah V j,k =C6/(dj,k​) 6, dimana C 6 adalah koefisien tetap, dan d j,k adalah jarak Euclidean antara spin j dan k. Efek langsung dari istilah interaksi ini adalah bahwa setiap keadaan di mana spin j dan spin k “naik” memiliki energi yang meningkat (dengan jumlah Vj,k). Dengan hati-hati merancang sisa program AHS, interaksi ini akan mencegah putaran tetangga dari keduanya berada dalam keadaan “naik”, efek yang umumnya dikenal sebagai “blokade Rydberg.”

## Bidang mengemudi


Pada awal program AHS, semua putaran (secara default) dimulai dalam keadaan “turun”, mereka berada dalam apa yang disebut fase feromagnetik. Mengawasi tujuan kami untuk mempersiapkan fase anti-feromagnetik, kami menentukan medan penggerak koheren yang bergantung pada waktu yang dengan lancar mentransisikan putaran dari keadaan ini ke keadaan banyak tubuh di mana keadaan “naik” lebih disukai. Hamiltonian yang sesuai dapat ditulis sebagai

![\[Persamaan matematika yang menggambarkan perhitungan fungsi drive Hamiltonian.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/HDrive.png)


di mana Ω (t), φ (t), Δ (t) adalah amplitudo global yang bergantung pada waktu (alias [frekuensi Rabi](https://en.wikipedia.org/wiki/Rabi_frequency)), fase, dan detuning medan penggerak yang mempengaruhi semua putaran secara seragam. Di sini S −,k =↓ k​ ⟨↑ k ^and S \$1,k =( S−,k) † =↑ k​ ⟨↓ k adalah operator penurun dan peningkatan spin k, masing-masing, dan n k =↑ ⟨↑ adalah operator yang sama seperti sebelumnya. k k Bagian Ω dari medan mengemudi secara koheren menggabungkan status “turun” dan “naik” dari semua putaran secara bersamaan, sedangkan bagian Δ mengontrol hadiah energi untuk keadaan “naik”.

Untuk memprogram transisi yang mulus dari fase feromagnetik ke fase anti-feromagnetik, kami menentukan bidang penggerak dengan kode berikut.

```
from braket.timings.time_series import TimeSeries
from braket.ahs.driving_field import DrivingField

# Smooth transition from "down" to "up" state
time_max = 4e-6  # seconds
time_ramp = 1e-7  # seconds
omega_max = 6300000.0  # rad / sec
delta_start = -5 * omega_max
delta_end = 5 * omega_max

omega = TimeSeries()
omega.put(0.0, 0.0)
omega.put(time_ramp, omega_max)
omega.put(time_max - time_ramp, omega_max)
omega.put(time_max, 0.0)

delta = TimeSeries()
delta.put(0.0, delta_start)
delta.put(time_ramp, delta_start)
delta.put(time_max - time_ramp, delta_end)
delta.put(time_max, delta_end)

phi = TimeSeries().put(0.0, 0.0).put(time_max, 0.0)

drive = DrivingField(
   amplitude=omega,
   phase=phi,
   detuning=delta
)
```

Kita dapat memvisualisasikan deret waktu bidang mengemudi dengan skrip berikut.

```
fig, axes = plt.subplots(3, 1, figsize=(12, 7), sharex=True)

ax = axes[0]
time_series = drive.amplitude.time_series
ax.plot(time_series.times(), time_series.values(), '.-')
ax.grid()
ax.set_ylabel('Omega [rad/s]')

ax = axes[1]
time_series = drive.detuning.time_series
ax.plot(time_series.times(), time_series.values(), '.-')
ax.grid()
ax.set_ylabel('Delta [rad/s]')

ax = axes[2]
time_series = drive.phase.time_series
# Note: time series of phase is understood as a piecewise constant function
ax.step(time_series.times(), time_series.values(), '.-', where='post')
ax.set_ylabel('phi [rad]')
ax.grid()
ax.set_xlabel('time [s]')

plt.show()  # This will show the plot below in an ipython or jupyter session
```

![\[Tiga grafik yang menunjukkan phi, delta, dan omega dari waktu ke waktu. Subplot teratas menunjukkan pertumbuhan tepat di atas 6 di rads/s mana ia tetap selama 4 detik hingga turun kembali ke 0. Subplot tengah menggambarkan pertumbuhan linier terkait turunan, dan subplot bawah menggambarkan garis datar mendekati nol.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/DrivingTimeSeries.png)


## Program AHS


Register, bidang mengemudi, (dan interaksi van der Waals implisit) membentuk program Simulasi Hamiltonian Analog. `ahs_program`

```
from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation

ahs_program = AnalogHamiltonianSimulation(
   register=register,
   hamiltonian=drive
)
```

## Berjalan di simulator lokal


Karena contoh ini kecil (kurang dari 15 putaran), sebelum menjalankannya pada QPU yang kompatibel dengan AHS, kita dapat menjalankannya di simulator AHS lokal yang dilengkapi dengan Braket SDK. Karena simulator lokal tersedia secara gratis dengan Braket SDK, ini adalah praktik terbaik untuk memastikan bahwa kode kami dapat dijalankan dengan benar.

Di sini, kita dapat mengatur jumlah bidikan ke nilai tinggi (katakanlah, 1 juta) karena simulator lokal melacak evolusi waktu status kuantum dan mengambil sampel dari keadaan akhir; karenanya, meningkatkan jumlah bidikan, sambil meningkatkan total runtime hanya sedikit.

```
from braket.devices import LocalSimulator

device = LocalSimulator("braket_ahs")

result_simulator = device.run(
   ahs_program,
   shots=1_000_000
).result()  # Takes about 5 seconds
```

## Menganalisis hasil simulator


Kami dapat menggabungkan hasil bidikan dengan fungsi berikut yang menyimpulkan status setiap putaran (yang mungkin “d” untuk “bawah”, “u” untuk “naik”, atau “e” untuk situs kosong), dan menghitung berapa kali setiap konfigurasi terjadi di seluruh bidikan.

```
from collections import Counter


def get_counts(result):
    """Aggregate state counts from AHS shot results

    A count of strings (of length = # of spins) are returned, where
    each character denotes the state of a spin (site):
      e: empty site
      u: up state spin
      d: down state spin

    Args:
      result (braket.tasks.analog_hamiltonian_simulation_quantum_task_result.AnalogHamiltonianSimulationQuantumTaskResult)

    Returns
       dict: number of times each state configuration is measured

    """
    state_counts = Counter()
    states = ['e', 'u', 'd']
    for shot in result.measurements:
        pre = shot.pre_sequence
        post = shot.post_sequence
        state_idx = np.array(pre) * (1 + np.array(post))
        state = "".join(map(lambda s_idx: states[s_idx], state_idx))
        state_counts.update((state,))
    return dict(state_counts)


counts_simulator = get_counts(result_simulator)  # Takes about 5 seconds
print(counts_simulator)
```

```
*[Output]*
{'dddddddd': 5, 'dddddddu': 12, 'ddddddud': 15, ...}
```

Berikut `counts` adalah kamus yang menghitung berapa kali setiap konfigurasi status diamati di seluruh bidikan. Kami juga dapat memvisualisasikannya dengan kode berikut.

```
from collections import Counter


def has_neighboring_up_states(state):
    if 'uu' in state:
        return True
    if state[0] == 'u' and state[-1] == 'u':
        return True
    return False


def number_of_up_states(state):
    return Counter(state)['u']


def plot_counts(counts):
    non_blockaded = []
    blockaded = []
    for state, count in counts.items():
        if not has_neighboring_up_states(state):
            collection = non_blockaded
        else:
            collection = blockaded
        collection.append((state, count, number_of_up_states(state)))

    blockaded.sort(key=lambda _: _[1], reverse=True)
    non_blockaded.sort(key=lambda _: _[1], reverse=True)

    for configurations, name in zip((non_blockaded,
                                     blockaded),
                                    ('no neighboring "up" states',
                                     'some neighboring "up" states')):
        plt.figure(figsize=(14, 3))
        plt.bar(range(len(configurations)), [item[1] for item in configurations])
        plt.xticks(range(len(configurations)))
        plt.gca().set_xticklabels([item[0] for item in configurations], rotation=90)
        plt.ylabel('shots')
        plt.grid(axis='y')
        plt.title(f'{name} configurations')
        plt.show()


plot_counts(counts_simulator)
```

![\[Bagan batang menunjukkan sejumlah besar bidikan tanpa konfigurasi status “naik” tetangga.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/AHSCounts1.png)


![\[Bagan batang menunjukkan bidikan dari beberapa konfigurasi status “naik” tetangga, dengan 4 status pada 1,0 bidikan.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/AHSCounts2.png)


Dari plot, kita dapat membaca pengamatan berikut verifikasi bahwa kita berhasil menyiapkan fase anti-feromagnetik.

1. Umumnya, negara bagian yang tidak diblokade (di mana tidak ada dua putaran tetangga yang berada dalam keadaan “naik”) lebih umum daripada negara bagian di mana setidaknya satu pasang putaran tetangga keduanya berada dalam keadaan “naik”.

1. Umumnya, status dengan lebih banyak eksitasi “naik” lebih disukai, kecuali konfigurasi diblokade.

1. Keadaan yang paling umum memang merupakan keadaan anti-feromagnetik yang sempurna dan. `"dudududu"` `"udududud"`

1. Keadaan paling umum kedua adalah keadaan di mana hanya ada 3 eksitasi “naik” dengan pemisahan berturut-turut 1, 2, 2. Ini menunjukkan bahwa interaksi van der Waals memiliki pengaruh (meskipun jauh lebih kecil) pada tetangga terdekat berikutnya juga.

## Berjalan di QuEra Aquila QPU


 **Prasyarat**[: Selain pip menginstal Braket [SDK](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk), jika Anda baru mengenal Amazon Braket, pastikan Anda telah menyelesaikan langkah-langkah Memulai yang diperlukan.](https://docs.aws.amazon.com/braket/latest/developerguide/braket-get-started.html)

**catatan**  
Jika Anda menggunakan instance notebook yang dihosting Braket, Braket SDK sudah diinstal sebelumnya dengan instance tersebut.

Dengan semua dependensi diinstal, kita dapat terhubung ke QPU. Aquila

```
from braket.aws import AwsDevice

aquila_qpu = AwsDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila")
```

Untuk membuat program AHS kami cocok untuk QuEra mesin, kami perlu membulatkan semua nilai untuk memenuhi tingkat presisi yang diizinkan oleh Aquila QPU. (Persyaratan ini diatur oleh parameter perangkat dengan “Resolusi” dalam namanya. Kita bisa melihatnya dengan mengeksekusi `aquila_qpu.properties.dict()` di notebook. Untuk detail lebih lanjut tentang kemampuan dan persyaratan Aquila, lihat buku catatan [Pengantar Aquila](https://github.com/aws/amazon-braket-examples/blob/main/examples/analog_hamiltonian_simulation/01_Introduction_to_Aquila.ipynb).) Kita bisa melakukan ini dengan memanggil `discretize` metode.

```
discretized_ahs_program = ahs_program.discretize(aquila_qpu)
```

Sekarang kita dapat menjalankan program (hanya menjalankan 100 tembakan untuk saat ini) pada Aquila QPU.

**catatan**  
Menjalankan program ini pada Aquila prosesor akan dikenakan biaya. Amazon Braket SDK menyertakan [Cost Tracker](https://aws.amazon.com/blogs/quantum-computing/managing-the-cost-of-your-experiments-in-amazon-braket/) yang memungkinkan pelanggan untuk menetapkan batas biaya serta melacak biaya mereka dalam waktu dekat.

```
task = aquila_qpu.run(discretized_ahs_program, shots=100)

metadata = task.metadata()
task_arn = metadata['quantumTaskArn']
task_status = metadata['status']

print(f"ARN: {task_arn}")
print(f"status: {task_status}")
```

```
*[Output]*
ARN: arn:aws:braket:us-east-1:123456789012:quantum-task/12345678-90ab-cdef-1234-567890abcdef
status: CREATED
```

Karena varians yang besar tentang berapa lama tugas kuantum dapat dijalankan (tergantung pada jendela ketersediaan dan pemanfaatan QPU), ada baiknya untuk mencatat ARN tugas kuantum, sehingga kami dapat memeriksa statusnya di lain waktu dengan cuplikan kode berikut.

```
# Optionally, in a new python session
from braket.aws import AwsQuantumTask

SAVED_TASK_ARN = "arn:aws:braket:us-east-1:123456789012:quantum-task/12345678-90ab-cdef-1234-567890abcdef"

task = AwsQuantumTask(arn=SAVED_TASK_ARN)
metadata = task.metadata()
task_arn = metadata['quantumTaskArn']
task_status = metadata['status']

print(f"ARN: {task_arn}")
print(f"status: {task_status}")
```

```
*[Output]*
ARN: arn:aws:braket:us-east-1:123456789012:quantum-task/12345678-90ab-cdef-1234-567890abcdef
status: COMPLETED
```

Setelah status SELESAI (yang juga dapat diperiksa dari halaman tugas kuantum [konsol](https://us-east-1.console.aws.amazon.com/braket/home?region=us-east-1#/tasks) Amazon Braket), kami dapat menanyakan hasilnya dengan:

```
result_aquila = task.result()
```

## Menganalisis hasil QPU


Menggunakan `get_counts` fungsi yang sama seperti sebelumnya, kita dapat menghitung hitungan:

```
counts_aquila = get_counts(result_aquila)
   print(counts_aquila)
```

```
*[Output]*
{'dddududd': 2, 'dudududu': 18, 'ddududud': 4, ...}
```

dan plot mereka dengan`plot_counts`:

```
plot_counts(counts_aquila)
```

![\[Bagan batang menunjukkan sejumlah besar bidikan tanpa konfigurasi status “naik” tetangga.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/QPUPlotCounts1.png)


![\[Bagan batang menunjukkan bidikan dari beberapa konfigurasi status “naik” tetangga, dengan 4 status pada 1,0 bidikan.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/QPUPlotCounts2.png)


Perhatikan bahwa sebagian kecil bidikan memiliki situs kosong (ditandai dengan “e”). Hal ini disebabkan oleh ketidaksempurnaan persiapan atom 1-2% per atom dari QPU. Aquila Selain itu, hasilnya cocok dengan simulasi dalam fluktuasi statistik yang diharapkan karena sejumlah kecil tembakan.

## Langkah selanjutnya


Selamat, Anda sekarang telah menjalankan beban kerja AHS pertama Anda di Amazon Braket menggunakan simulator AHS lokal dan QPU. Aquila

[Untuk mempelajari lebih lanjut tentang fisika Rydberg, Simulasi Hamiltonian Analog dan Aquila perangkat, lihat contoh notebook kami.](https://github.com/aws/amazon-braket-examples/tree/main/examples/analog_hamiltonian_simulation)

# Kirim program analog menggunakan QuEra Aquila


Halaman ini memberikan dokumentasi komprehensif tentang kemampuan Aquila mesin dariQuEra. Detail yang dibahas di sini adalah sebagai berikut: 

1. Hamiltonian berparameter disimulasikan oleh Aquila

1. Parameter program AHS

1. Konten hasil AHS

1. Aquilaparameter kemampuan

**Topics**
+ [

## Hamiltonian
](#braket-quera-aquila-device-hamiltonian)
+ [

## Skema program Braket AHS
](#braket-quera-ahs-program-schema)
+ [

## Skema hasil tugas Braket AHS
](#braket-quera-ahs-task-result-schema)
+ [

## QuEra skema properti perangkat
](#braket-quera-device-properties-schema)

## Hamiltonian


AquilaMesin dari QuEra mensimulasikan Hamiltonian berikut (tergantung waktu) secara asli:

![\[Persamaan matematika dengan penjumlahan yang mewakili Hamiltonian dari suatu sistem, yang melibatkan penggerak, detuning lokal, dan suku kopling interdot.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/TimeDependentDrivingHamiltonian.png)


**catatan**  
Akses ke detuning lokal adalah [kemampuan Eksperimental](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html) dan tersedia berdasarkan permintaan melalui Braket Direct.

di mana
+ H drive,k (t) =( 1/2Ω (t) e iφ (t) S −,k \$1 1/2Ω (t) e −Iφ (t) S) \$1 (−Δ global (t\$1,k​) n), k
  + Ω (t) adalah amplitudo penggerak global yang bergantung pada waktu (alias frekuensi Rabi), dalam satuan (rad/ s)
  + φ (t) adalah fase global yang bergantung pada waktu, diukur dalam radian
  + S −,k​ dan S \$1,k adalah operator penurun dan peningkatan putaran atom k (dalam basis \$1↓⟩ =\$1g⟩, \$1↑=\$1r⟩, mereka adalah S =\$1g⟨r\$1, S =( S−) † =\$1r⟨g\$1) \$1 −
  + Δ global (t) adalah detuning global yang bergantung pada waktu
  + n k adalah operator proyeksi pada keadaan Rydberg atom k (yaitu, n=\$1r⟨r\$1)
+ H local detuning,k (t) =-Δ local (t) h n k k
  + Δ local (t) adalah faktor yang bergantung pada waktu dari pergeseran frekuensi lokal, dalam satuan (rad/s)
  + h k adalah faktor yang bergantung pada lokasi, bilangan tak berdimensi antara 0,0 dan 1,0
+ V vdw,k,l = C6​/(dk,l) 6 n k nl,
  + C 6 adalah koefisien van der Waals, dalam satuan (rad/s) \$1 (m) ^6
  + d k,l adalah jarak Euclidean antara atom k dan l, diukur dalam meter.

Pengguna memiliki kontrol atas parameter berikut melalui skema program Braket AHS.
+ Susunan atom 2-d (kkkoordinat x dan y dari setiap atom k, dalam satuan um), yang mengontrol jarak atom berpasangan d k,l​ dengan k, l=1,2,... N
+ Ω (t), frekuensi Rabi global yang bergantung pada waktu, dalam satuan (rad/s)
+ φ (t), fase global yang bergantung pada waktu, dalam satuan (rad)
+ Δ global (t), detuning global yang bergantung pada waktu, dalam satuan (rad/s)
+ Δ local (t), faktor yang bergantung pada waktu (global) dari besarnya detuning lokal, dalam satuan (rad/s)
+ hk, faktor yang bergantung pada lokasi (statis) dari besarnya detuning lokal, bilangan tak berdimensi antara 0,0 dan 1,0

**catatan**  
Pengguna tidak dapat mengontrol level mana yang terlibat (yaitu, S, S −\$1​, n operator tetap) atau kekuatan koefisien interaksi Rydberg-Rydberg (C). 6

## Skema program Braket AHS


 **Braket.ir.ahs.program\$1v1.Program objek** (contoh)

**catatan**  
Jika fitur [detuning lokal](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning) tidak diaktifkan untuk akun Anda, gunakan `localDetuning=[]` dalam contoh berikut.

```
Program(
    braketSchemaHeader=BraketSchemaHeader(
        name='braket.ir.ahs.program',
        version='1'
    ),
    setup=Setup(
        ahs_register=AtomArrangement(
            sites=[
                [Decimal('0'), Decimal('0')],
                [Decimal('0'), Decimal('4e-6')],
                [Decimal('4e-6'), Decimal('0')]
            ],
            filling=[1, 1, 1]
        )
    ),
    hamiltonian=Hamiltonian(
        drivingFields=[
            DrivingField(
                amplitude=PhysicalField(
                    time_series=TimeSeries(
                        values=[Decimal('0'), Decimal('15700000.0'), Decimal('15700000.0'), Decimal('0')],
                        times=[Decimal('0'), Decimal('0.000001'), Decimal('0.000002'), Decimal('0.000003')]
                    ),
                    pattern='uniform'
                ),
                phase=PhysicalField(
                    time_series=TimeSeries(
                        values=[Decimal('0'), Decimal('0')],
                        times=[Decimal('0'), Decimal('0.000003')]
                    ),
                    pattern='uniform'
                ),
                detuning=PhysicalField(
                    time_series=TimeSeries(
                        values=[Decimal('-54000000.0'), Decimal('54000000.0')],
                        times=[Decimal('0'), Decimal('0.000003')]
                    ),
                    pattern='uniform'
                )
            )
        ],
        localDetuning=[
            LocalDetuning(
                magnitude=PhysicalField(
                    times_series=TimeSeries(
                        values=[Decimal('0'), Decimal('25000000.0'), Decimal('25000000.0'), Decimal('0')],
                        times=[Decimal('0'), Decimal('0.000001'), Decimal('0.000002'), Decimal('0.000003')]
                    ),
                    pattern=Pattern([Decimal('0.8'), Decimal('1.0'), Decimal('0.9')])
                )
            )
        ]
    )
)
```

**JSON** (contoh)

**catatan**  
Jika fitur [detuning lokal](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning) tidak diaktifkan untuk akun Anda, gunakan `"localDetuning": []` dalam contoh berikut.

```
{
    "braketSchemaHeader": {
        "name": "braket.ir.ahs.program",
        "version": "1"
    },
    "setup": {
        "ahs_register": {
            "sites": [
                [0E-7, 0E-7], 
                [0E-7, 4E-6],
                [4E-6, 0E-7]
            ],
            "filling": [1, 1, 1]
        }
    },
    "hamiltonian": {
        "drivingFields": [
            {
                "amplitude": {
                    "time_series": {
                        "values": [0.0, 15700000.0, 15700000.0, 0.0],
                        "times": [0E-9, 0.000001000, 0.000002000, 0.000003000]
                    },
                    "pattern": "uniform"
                },
                "phase": {
                    "time_series": {
                        "values": [0E-7, 0E-7],
                        "times": [0E-9, 0.000003000]
                    },
                    "pattern": "uniform"
                },
                "detuning": {
                    "time_series": {
                        "values": [-54000000.0, 54000000.0],
                        "times": [0E-9, 0.000003000]
                    },
                    "pattern": "uniform"
                }
            }
        ],
        "localDetuning": [
            {
                "magnitude": {
                    "time_series": {
                        "values": [0.0, 25000000.0, 25000000.0, 0.0],
                        "times": [0E-9, 0.000001000, 0.000002000, 0.000003000]
                    },
                    "pattern": [0.8, 1.0, 0.9]
                }
            }
        ]
    }
}
```


**Bidang utama**  

| Bidang program | jenis | deskripsi | 
| --- | --- | --- | 
|  setup.ahs\$1register.sites  |  Daftar [Daftar [Desimal]]  |  Daftar koordinat 2-d di mana pinset menjebak atom  | 
|  setup.ahs\$1register.filling  |  Daftar [int]  |  Menandai atom yang menempati situs perangkap dengan 1, dan situs kosong dengan 0  | 
|  Hamiltonian.drivingFields [] .amplitude.time\$1series.times  |  Daftar [Desimal]  |  titik waktu amplitudo mengemudi, Omega (t)  | 
|  Hamiltonian.drivingFields [] .amplitude.time\$1series.values  |  Daftar [Desimal]  |  nilai amplitudo mengemudi, Omega (t)  | 
|  Hamiltonian.drivingFields [] .amplitude.pattern  |  str  |  pola spasial amplitudo mengemudi, Omega (t); harus 'seragam'  | 
|  Hamiltonian.drivingFields [] .phase.time\$1series.times  |  Daftar [Desimal]  |  titik waktu fase mengemudi, phi (t)  | 
|  Hamiltonian.drivingFields [] .phase.time\$1series.values  |  Daftar [Desimal]  |  nilai fase mengemudi, phi (t)  | 
|  Hamiltonian.drivingFields [] .phase.pattern  |  str  |  pola spasial fase mengemudi, phi (t); harus 'seragam'  | 
|  Hamiltonian.drivingFields [] .detuning.time\$1series.times  |  Daftar [Desimal]  |  titik waktu detuning mengemudi, Delta\$1global (t)  | 
|  Hamiltonian.drivingFields [] .detuning.time\$1series.values  |  Daftar [Desimal]  |  nilai detuning mengemudi, delta\$1global (t)  | 
|  Hamiltonian.drivingFields [] .detuning.pattern  |  str  |  pola spasial detuning mengemudi, Delta\$1global (t); harus 'seragam'  | 
|  Hamiltonian.localdeTuning [] .magnitude.time\$1series.times  |  Daftar [Desimal]  |  titik waktu dari faktor yang bergantung pada waktu dari magnitudo detuning lokal, delta\$1local (t)  | 
|  Hamiltonian.localdeTuning [] .magnitude.time\$1series.values  |  Daftar [Desimal]  |  nilai faktor yang bergantung pada waktu dari besaran detuning lokal, delta\$1local (t)  | 
|  Hamiltonian.localdeTuning [] .magnitude.pattern  |  Daftar [Desimal]  |  faktor yang bergantung pada situs dari besaran detuning lokal, h\$1k (nilai sesuai dengan situs di setup.ahs\$1register.sites)  | 


**Kolom metadata**  

| Bidang program | jenis | deskripsi | 
| --- | --- | --- | 
|  braketSchemaHeader.nama  |  str  |  nama skema; harus 'braket.ir.ahs.program'  | 
|  braketSchemaHeader.versi  |  str  |  versi skema  | 

## Skema hasil tugas Braket AHS


 **braket.tasks.analog\$1hamiltonian\$1simulation\$1quantum\$1task\$1result. AnalogHamiltonianSimulationQuantumTaskResult**(contoh)

```
AnalogHamiltonianSimulationQuantumTaskResult(
    task_metadata=TaskMetadata(
        braketSchemaHeader=BraketSchemaHeader(
            name='braket.task_result.task_metadata',
            version='1'
        ),
        id='arn:aws:braket:us-east-1:123456789012:quantum-task/12345678-90ab-cdef-1234-567890abcdef',
        shots=2,
        deviceId='arn:aws:braket:us-east-1::device/qpu/quera/Aquila',
        deviceParameters=None,
        createdAt='2022-10-25T20:59:10.788Z',
        endedAt='2022-10-25T21:00:58.218Z',
        status='COMPLETED',
        failureReason=None
    ),
    measurements=[
        ShotResult(
            status=<AnalogHamiltonianSimulationShotStatus.SUCCESS: 'Success'>,

            pre_sequence=array([1, 1, 1, 1]),
            post_sequence=array([0, 1, 1, 1])
        ),

        ShotResult(
            status=<AnalogHamiltonianSimulationShotStatus.SUCCESS: 'Success'>,

            pre_sequence=array([1, 1, 0, 1]),
            post_sequence=array([1, 0, 0, 0])
        )
    ]
)
```

 **JSON** (contoh)

```
{
    "braketSchemaHeader": {
        "name": "braket.task_result.analog_hamiltonian_simulation_task_result",
        "version": "1"
    },
    "taskMetadata": {
        "braketSchemaHeader": {
            "name": "braket.task_result.task_metadata",
            "version": "1"
        },
        "id": "arn:aws:braket:us-east-1:123456789012:quantum-task/12345678-90ab-cdef-1234-567890abcdef",
        "shots": 2,
        "deviceId": "arn:aws:braket:us-east-1::device/qpu/quera/Aquila",

        "createdAt": "2022-10-25T20:59:10.788Z",
        "endedAt": "2022-10-25T21:00:58.218Z",
        "status": "COMPLETED"

    },
    "measurements": [
        {
            "shotMetadata": {"shotStatus": "Success"},
            "shotResult": {
                "preSequence": [1, 1, 1, 1],
                "postSequence": [0, 1, 1, 1]
            }
        },
        {
            "shotMetadata": {"shotStatus": "Success"},
            "shotResult": {
                "preSequence": [1, 1, 0, 1],
                "postSequence": [1, 0, 0, 0]
            }
        }
    ],
    "additionalMetadata": {
        "action": {...}
        "queraMetadata": {
            "braketSchemaHeader": {
                "name": "braket.task_result.quera_metadata",
                "version": "1"
            },
            "numSuccessfulShots": 100
        }
    }
}
```


**Bidang utama**  

| Bidang hasil tugas | jenis | deskripsi | 
| --- | --- | --- | 
|  pengukuran [] .shotResult.Presequence  |  Daftar [int]  |  Bit pengukuran pra-urutan (satu untuk setiap situs atom) untuk setiap bidikan: 0 jika situs kosong, 1 jika situs diisi, diukur sebelum urutan pulsa yang menjalankan evolusi kuantum  | 
|  pengukuran [] .shotResult.PostSequence  |  Daftar [int]  |  Bit pengukuran pasca-urutan untuk setiap bidikan: 0 jika atom dalam keadaan Rydberg atau situs kosong, 1 jika atom dalam keadaan dasar, diukur pada akhir urutan pulsa yang menjalankan evolusi kuantum  | 


**Kolom metadata**  

| Bidang hasil tugas | jenis | deskripsi | 
| --- | --- | --- | 
|  braketSchemaHeader.nama  |  str  |  nama skema; harus 'braket.task\$1result.analog\$1hamiltonian\$1simulation\$1task\$1result'  | 
|  braketSchemaHeader.versi  |  str  |  versi skema  | 
|  Tugasmetadata. braketSchemaHeader.nama  |  str  |  nama skema; harus 'braket.task\$1result.task\$1metadata'  | 
|  Tugasmetadata. braketSchemaHeader.versi  |  str  |  versi skema  | 
|  Taskmetadata.id  |  str  |  ID tugas kuantum. Untuk tugas AWS kuantum, ini adalah tugas kuantum ARN.  | 
|  Taskmetadata.shots  |  int  |  Jumlah bidikan untuk tugas kuantum  | 
|  Taskmetadata.shots.deviceID  |  str  |  ID perangkat tempat tugas kuantum dijalankan. Untuk AWS perangkat, ini adalah perangkat ARN.  | 
|  taskmetadata.shots.createdat  |  str  |  Stempel waktu pembuatan; formatnya harus dalam format RFC3339 ISO-8601/string: MM: SS.sssz. YYYY-MM-DDTHH Default adalah None.  | 
|  taskmetadata.shots.endedat  |  str  |  Stempel waktu kapan tugas kuantum berakhir; formatnya harus dalam format RFC3339 ISO-8601/ string: mm:ss.sssz. YYYY-MM-DDTHH Default adalah None.  | 
|  Taskmetadata.shots.status  |  str  |  Status tugas kuantum (CREATED, QUEUED, RUNNING, COMPLETED, FAILED). Default adalah None.  | 
|  taskmetadata.shots.failurereason  |  str  |  Alasan kegagalan tugas kuantum. Default adalah None.  | 
|  TambahanMetadata.Action  |  Braket.ir.ahs.program\$1v1.program  |  (Lihat bagian [skema program Braket AHS](#braket-quera-ahs-program-schema))  | 
|  AdditionalMetadata.action. braketSchemaHeader.querametadata.name  |  str  |  nama skema; harus 'braket.task\$1result.quera\$1metadata'  | 
|  AdditionalMetadata.action. braketSchemaHeader.querametadata.versi  |  str  |  versi skema  | 
|  AdditionalMetadata.action. numSuccessfulShots  |  int  |  jumlah tembakan yang benar-benar berhasil; harus sama dengan jumlah tembakan yang diminta  | 
|  pengukuran [] .shotmetadata.shotStatus  |  int  |  Status tembakan, (Sukses, Sukses sebagian, Kegagalan); harus “Sukses”  | 

## QuEra skema properti perangkat


 **braket.device\$1schema.quera.quera\$1device\$1capabilities\$1v1. QueraDeviceCapabilities**(contoh)

```
QueraDeviceCapabilities(
    service=DeviceServiceProperties(
        braketSchemaHeader=BraketSchemaHeader(
            name='braket.device_schema.device_service_properties', 
            version='1'
            ), 
            executionWindows=[
                DeviceExecutionWindow(
                    executionDay=<ExecutionDay.MONDAY: 'Monday'>, 
                    windowStartHour=datetime.time(1, 0), 
                    windowEndHour=datetime.time(23, 59, 59)
                ), 
                DeviceExecutionWindow(
                    executionDay=<ExecutionDay.TUESDAY: 'Tuesday'>, 
                    windowStartHour=datetime.time(0, 0), 
                    windowEndHour=datetime.time(12, 0)
                ), 
                DeviceExecutionWindow(
                    executionDay=<ExecutionDay.WEDNESDAY: 'Wednesday'>, 
                    windowStartHour=datetime.time(0, 0), 
                    windowEndHour=datetime.time(12, 0)
                ), 
                DeviceExecutionWindow(
                    executionDay=<ExecutionDay.FRIDAY: 'Friday'>, 
                    windowStartHour=datetime.time(0, 0), 
                    windowEndHour=datetime.time(23, 59, 59)
                ), 
                DeviceExecutionWindow(
                    executionDay=<ExecutionDay.SATURDAY: 'Saturday'>, 
                    windowStartHour=datetime.time(0, 0), 
                    windowEndHour=datetime.time(23, 59, 59)
                ), 
                DeviceExecutionWindow(
                    executionDay=<ExecutionDay.SUNDAY: 'Sunday'>, 
                    windowStartHour=datetime.time(0, 0), 
                    windowEndHour=datetime.time(12, 0)
                )
            ], 
            shotsRange=(1, 1000), 
            deviceCost=DeviceCost(
                price=0.01, 
                unit='shot'
            ), 
            deviceDocumentation=
                DeviceDocumentation(
                    imageUrl='https://a.b.cdn.console.awsstatic.com/59534b58c709fc239521ef866db9ea3f1aba73ad3ebcf60c23914ad8c5c5c878/a6cfc6fca26cf1c2e1c6.png', 
                    summary='Analog quantum processor based on neutral atom arrays', 
                    externalDocumentationUrl='https://www.quera.com/aquila'
                ), 
                deviceLocation='Boston, USA', 
                updatedAt=datetime.datetime(2024, 1, 22, 12, 0, tzinfo=datetime.timezone.utc), 
                getTaskPollIntervalMillis=None
    ), 
    action={
        <DeviceActionType.AHS: 'braket.ir.ahs.program'>: DeviceActionProperties(
                version=['1'], 
                actionType=<DeviceActionType.AHS: 'braket.ir.ahs.program'>
            )
    }, 
    deviceParameters={}, 
    braketSchemaHeader=BraketSchemaHeader(
        name='braket.device_schema.quera.quera_device_capabilities', 
        version='1'
    ), 
    paradigm=QueraAhsParadigmProperties(
        ...
        # See https://github.com/amazon-braket/amazon-braket-schemas-python/blob/main/src/braket/device_schema/quera/quera_ahs_paradigm_properties_v1.py
        ...
    )  
)
```

 **JSON** (contoh)

```
{
    "service": {
        "braketSchemaHeader": {
            "name": "braket.device_schema.device_service_properties",
            "version": "1"
        },
        "executionWindows": [
            {
                "executionDay": "Monday",
                "windowStartHour": "01:00:00",
                "windowEndHour": "23:59:59"
            },
            {
                "executionDay": "Tuesday",
                "windowStartHour": "00:00:00",
                "windowEndHour": "12:00:00"
            },
            {
                "executionDay": "Wednesday",
                "windowStartHour": "00:00:00",
                "windowEndHour": "12:00:00"
            },
            {
                "executionDay": "Friday",
                "windowStartHour": "00:00:00",
                "windowEndHour": "23:59:59"
            },
            {
                "executionDay": "Saturday",
                "windowStartHour": "00:00:00",
                "windowEndHour": "23:59:59"
            },
            {
                "executionDay": "Sunday",
                "windowStartHour": "00:00:00",
                "windowEndHour": "12:00:00"
            }
        ],
        "shotsRange": [
            1,
            1000
        ],
        "deviceCost": {
            "price": 0.01,
            "unit": "shot"
        },
        "deviceDocumentation": {
            "imageUrl": "https://a.b.cdn.console.awsstatic.com/59534b58c709fc239521ef866db9ea3f1aba73ad3ebcf60c23914ad8c5c5c878/a6cfc6fca26cf1c2e1c6.png",
            "summary": "Analog quantum processor based on neutral atom arrays",
            "externalDocumentationUrl": "https://www.quera.com/aquila"
        },
        "deviceLocation": "Boston, USA",
        "updatedAt": "2024-01-22T12:00:00+00:00"
    },
    "action": {
        "braket.ir.ahs.program": {
            "version": [
                "1"
            ],
            "actionType": "braket.ir.ahs.program"
        }
    },
    "deviceParameters": {},
    "braketSchemaHeader": {
        "name": "braket.device_schema.quera.quera_device_capabilities",
        "version": "1"
    },
    "paradigm": {
        ...
        # See Aquila device page > "Calibration" tab > "JSON" page
        ...
    }
}
```


**Bidang properti layanan**  

| Bidang properti layanan | jenis | deskripsi | 
| --- | --- | --- | 
|  Service.ExecutionWindows [] .ExecutionDay  |  ExecutionDay  |  Hari dari jendela eksekusi; harus 'Setiap Hari', 'Hari Kerja', 'Akhir Pekan', 'Senin', 'Selasa', 'Rabu', Kamis', 'Jumat', 'Sabtu' atau 'Minggu'  | 
|  Service.ExecutionWindows []. windowStartHour  |  datetime.time  |  Format 24 jam UTC saat jendela eksekusi dimulai  | 
|  Service.ExecutionWindows []. windowEndHour  |  datetime.time  |  Format 24 jam UTC saat jendela eksekusi berakhir  | 
|  Service.qpu\$1capabilities.service.shotsrange  |  Tupel [int, int]  |  Jumlah bidikan minimum dan maksimum untuk perangkat  | 
|  Service.qpu\$1capabilities.service.devicecost.price  |  float  |  Harga perangkat dalam hal dolar AS  | 
|  Service.qpu\$1capabilities.service.devicecost.unit  |  str  |  unit untuk mengisi harga, misalnya: 'menit', 'jam', 'tembakan', 'tugas'  | 


**Kolom metadata**  

| Bidang metadata | jenis | deskripsi | 
| --- | --- | --- | 
|  aksi [] .versi  |  str  |  versi skema program AHS  | 
|  tindakan [] .actionType  |  ActionType  |  Nama skema program AHS; harus 'braket.ir.ahs.program'  | 
|  layanan. braketSchemaHeader.nama  |  str  |  nama skema; harus 'braket.device\$1schema.device\$1service\$1properties'  | 
|  layanan. braketSchemaHeader.versi  |  str  |  versi skema  | 
|  Service.deviceDocumentation.ImageUrl  |  str  |  URL untuk gambar perangkat  | 
|  Service.deviceDocumentation.Summary  |  str  |  deskripsi singkat tentang perangkat  | 
|  Service.deviceDocumentation. externalDocumentationUrl  |  str  |  URL dokumentasi eksternal  | 
|  Service.deviceLocation  |  str  |  lokasi geografis untuk perangkat  | 
|  Service.updateDat  |  datetime  |  waktu ketika properti perangkat terakhir diperbarui  | 

# Bekerja dengan AWS Boto3
(Lanjutan) Bekerja dengan AWS Boto3

Boto3 adalah AWS SDK untuk Python. Dengan Boto3, pengembang Python dapat membuat, mengkonfigurasi, dan mengelola Layanan AWS, seperti Braket. Amazon Boto3 menyediakan akses berorientasi objekAPI, serta tingkat rendah ke Amazon Braket.

Ikuti instruksi di [Panduan Memulai Cepat Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) untuk mempelajari cara menginstal dan mengkonfigurasi Boto3.

Boto3 menyediakan fungsi inti yang bekerja bersama dengan SDK Python Amazon Braket untuk membantu Anda mengkonfigurasi dan menjalankan tugas kuantum Anda. Pelanggan Python selalu perlu menginstal Boto3, karena itu adalah implementasi inti. Jika Anda ingin menggunakan metode pembantu tambahan, Anda juga perlu menginstal SDK Amazon Braket.

Misalnya, saat Anda menelepon`CreateQuantumTask`, Amazon Braket SDK mengirimkan permintaan ke Boto3, yang kemudian memanggil file. AWS API

**Topics**
+ [

# Nyalakan klien Amazon Braket Boto3
](braket-using-boto3-client.md)
+ [

# Konfigurasikan AWS CLI profil untuk Boto3 dan Braket SDK
](braket-using-boto3-profiles.md)

# Nyalakan klien Amazon Braket Boto3


Untuk menggunakan Boto3 dengan Amazon Braket, Anda harus mengimpor Boto3 dan kemudian menentukan klien yang Anda gunakan untuk terhubung ke Amazon Braket. API Dalam contoh berikut, klien Boto3 diberi nama. `braket`

```
import boto3
import botocore

braket = boto3.client("braket")
```

**catatan**  
[Braket mendukung IPv6](https://docs.aws.amazon.com/vpc/latest/userguide/aws-ipv6-support.html). [Jika Anda menggunakan jaringan IPv6 -only atau ingin memastikan beban kerja Anda menggunakan IPv6 lalu lintas, gunakan titik akhir dual-stack seperti yang diuraikan dalam panduan titik akhir Dual-stack dan FIPS.](https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html)

Sekarang karena Anda memiliki klien `braket` yang telah ditetapkan, Anda dapat membuat permintaan dan tanggapan proses dari layanan Amazon Braket. Anda bisa mendapatkan detail lebih lanjut tentang permintaan dan data tanggapan di [Referensi API](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/braket.html).

**Topics**
+ [

## Mencari perangkat
](#braket-using-boto3-example-search-devices)
+ [

## Ambil perangkat
](#braket-using-boto3-example-retrieve-devices)
+ [

## Membuat tugas kuantum
](#braket-using-boto3-example-create-task)
+ [

## Mengambil tugas kuantum
](#braket-using-boto3-example-retrieve-task)
+ [

## Mencari tugas kuantum
](#braket-using-boto3-example-search-tasks)
+ [

## Batalkan tugas kuantum
](#braket-using-boto3-example-cancel-task)

## Mencari perangkat

+  `search_devices(**kwargs)` 

Cari perangkat menggunakan filter yang ditentukan.

```
# Pass search filters and optional parameters when sending the
# request and capture the response
response = braket.search_devices(filters=[{
    'name': 'deviceArn',
    'values': ['arn:aws:braket:::device/quantum-simulator/amazon/sv1']
}], maxResults=10)

print(f"Found {len(response['devices'])} devices")

for i in range(len(response['devices'])):
    device = response['devices'][i]
    print(device['deviceArn'])
```

## Ambil perangkat

+  `get_device(deviceArn)` 

Ambil perangkat yang tersedia di Amazon Braket.

```
# Pass the device ARN when sending the request and capture the repsonse
response = braket.get_device(deviceArn='arn:aws:braket:::device/quantum-simulator/amazon/sv1')

print(f"Device {response['deviceName']} is {response['deviceStatus']}")
```

## Membuat tugas kuantum

+  `create_quantum_task(**kwargs)` 

Buat tugas kuantum.

```
# Create parameters to pass into create_quantum_task()
kwargs = {
    # Create a Bell pair
    'action': '{"braketSchemaHeader": {"name": "braket.ir.jaqcd.program", "version": "1"}, "results": [], "basis_rotation_instructions": [], "instructions": [{"type": "h", "target": 0}, {"type": "cnot", "control": 0, "target": 1}]}',
    # Specify the SV1 Device ARN
    'deviceArn': 'arn:aws:braket:::device/quantum-simulator/amazon/sv1',
    # Specify 2 qubits for the Bell pair
    'deviceParameters': '{"braketSchemaHeader": {"name": "braket.device_schema.simulators.gate_model_simulator_device_parameters", "version": "1"}, "paradigmParameters": {"braketSchemaHeader": {"name": "braket.device_schema.gate_model_parameters", "version": "1"}, "qubitCount": 2}}',
    # Specify where results should be placed when the quantum task completes.
    # You must ensure the S3 Bucket exists before calling create_quantum_task()
    'outputS3Bucket': 'amazon-braket-examples',
    'outputS3KeyPrefix': 'boto-examples',
    # Specify number of shots for the quantum task
    'shots': 100
}

# Send the request and capture the response
response = braket.create_quantum_task(**kwargs)

print(f"Quantum task {response['quantumTaskArn']} created")
```

## Mengambil tugas kuantum

+  `get_quantum_task(quantumTaskArn)` 

Ambil tugas kuantum yang ditentukan.

```
# Pass the quantum task ARN when sending the request and capture the response
response = braket.get_quantum_task(quantumTaskArn='arn:aws:braket:us-west-1:123456789012:quantum-task/ce78c429-cef5-45f2-88da-123456789012')

print(response['status'])
```

## Mencari tugas kuantum

+  `search_quantum_tasks(**kwargs)` 

Cari tugas kuantum yang cocok dengan nilai filter yang ditentukan.

```
# Pass search filters and optional parameters when sending the
# request and capture the response
response = braket.search_quantum_tasks(filters=[{
    'name': 'deviceArn',
    'operator': 'EQUAL',
    'values': ['arn:aws:braket:::device/quantum-simulator/amazon/sv1']
}], maxResults=25)

print(f"Found {len(response['quantumTasks'])} quantum tasks")

for n in range(len(response['quantumTasks'])):
    task = response['quantumTasks'][n]
    print(f"Quantum task {task['quantumTaskArn']} for {task['deviceArn']} is {task['status']}")
```

## Batalkan tugas kuantum

+  `cancel_quantum_task(quantumTaskArn)` 

Batalkan tugas kuantum yang ditentukan.

```
# Pass the quantum task ARN when sending the request and capture the response
response = braket.cancel_quantum_task(quantumTaskArn='arn:aws:braket:us-west-1:123456789012:quantum-task/ce78c429-cef5-45f2-88da-123456789012')

print(f"Quantum task {response['quantumTaskArn']} is {response['cancellationStatus']}")
```

# Konfigurasikan AWS CLI profil untuk Boto3 dan Braket SDK


Amazon Braket SDK bergantung pada AWS CLI kredenal default, kecuali jika Anda secara eksplisit menentukan sebaliknya. Sebaiknya simpan default saat menjalankan buku catatan Amazon Braket yang dikelola karena Anda harus memberikan peran IAM yang memiliki izin untuk meluncurkan instance notebook.

Secara opsional, jika Anda menjalankan kode secara lokal (misalnya pada instans Amazon EC2), Anda dapat membuat profil bernama. AWS CLI Anda dapat memberikan setiap profil set izin yang berbeda, dan bukan secara teratur menimpa profil default.

Bagian ini memberikan penjelasan singkat tentang cara mengkonfigurasi CLI tersebut `profile` dan bagaimana memasukkan profil itu ke dalam Amazon Braket sehingga API panggilan dilakukan dengan izin dari profil itu.

**Topics**
+ [

## Langkah 1: Konfigurasikan AWS CLI lokal `profile`
](#braket-using-boto3-profiles-step-1)
+ [

## Langkah 2: Buat objek sesi Boto3
](#braket-using-boto3-profiles-step-2)
+ [

## Langkah 3: Masukkan sesi Boto3 ke dalam Braket AwsSession
](#braket-using-boto3-profiles-step-3)

## Langkah 1: Konfigurasikan AWS CLI lokal `profile`


Ini di luar cakupan dokumen ini untuk menjelaskan cara membuat pengguna dan cara mengkonfigurasi profil non-default. Untuk informasi lebih lanjut tentang topik ini, lihat:
+  [Memulai](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) 
+  [Mengkonfigurasi yang akan AWS CLI digunakan AWS IAM Identity Center](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html) 

Untuk menggunakan Amazon Braket, Anda harus memberikan pengguna ini — dan CLI terkait `profile` — dengan izin Braket yang diperlukan. Misalnya, Anda dapat melampirkan **AmazonBraketFullAccess**kebijakan.

## Langkah 2: Buat objek sesi Boto3


Untuk membuat objek sesi Boto3, gunakan contoh kode berikut.

```
from boto3 import Session

# Insert CLI profile name here
boto_sess = Session(profile_name=`profile`)
```

**catatan**  
Jika API panggilan yang diharapkan memiliki batasan berbasis Region yang tidak selaras dengan Region `profile` default, Anda dapat menentukan Region untuk sesi Boto3 seperti yang ditunjukkan pada contoh berikut.

```
# Insert CLI profile name _and_ region
boto_sess = Session(profile_name=`profile`, region_name=`region`)
```

Untuk argumen yang ditunjuk sebagai`region`, gantikan nilai yang sesuai dengan salah satu Wilayah AWS di mana Amazon Braket tersedia seperti`us-east-1`,`us-west-1`, dan sebagainya.

## Langkah 3: Masukkan sesi Boto3 ke dalam Braket AwsSession


Contoh berikut menunjukkan cara menginisialisasi sesi Boto3 Braket dan membuat instance perangkat dalam sesi itu.

```
from braket.aws import AwsSession, AwsDevice

# Initialize Braket session with Boto3 Session credentials
aws_session = AwsSession(boto_session=boto_sess)

# Instantiate any Braket QPU device with the previously initiated AwsSession
sim_arn = 'arn:aws:braket:::device/quantum-simulator/amazon/sv1'
device = AwsDevice(sim_arn, aws_session=aws_session)
```

Setelah penyiapan ini selesai, Anda dapat mengirimkan tugas kuantum ke `AwsDevice` objek yang dipakai (dengan memanggil `device.run(…​)` perintah misalnya). Semua API panggilan yang dilakukan oleh perangkat tersebut dapat menggunakan kredenal IAM yang terkait dengan profil CLI yang sebelumnya Anda tetapkan sebagai. `profile`