**Cirq** adalah pustaka perangkat lunak, ditulis menggunakan Python, yang digunakan untuk menulis, memanipulasi, dan mengoptimisasi sirkuit kuantum, dan kemudian menjalankannya pada komputer dan simulator kuantum. Cirq menyediakan abstraksi untuk menangani komputer *noisy intermediate-scale quantum* yang ada saat ini, di mana rincian-rincian dari perangkat keras bersifat vital dalam mencapai hasil state-of-the-art.

Sejarah
-------

Cirq dikembangkan oleh Google Quantum AI Team, dan versi alpha publiknya diumumkan di International Workshop on Quantum Software and Quantum Machine Learning pada 18 Juni 2018. Sebuah demo oleh QC Ware menunjukkan implementasi dari QAOA yang menyelesaikan contoh masalah potongan maksimum yang dipecahkan pada sebuah simulator Cirq.

Fitur
-----

### Konstruksi sirkuit

Struktur-struktur data inti yang menyusun sebuah sirkuit:

#### Sirkuit

Representasi utama dari program kuantum di dalam Cirq adalah kelas `**Circuit**`. Sebuah `**Circuit**` merupakan kumpulan dari `**Moments**`. `**Moment**` merupakan kumpulan dari `**Operations**` yang bekerja dalam irisan waktu yang bersamaan. `**Operation**` adalah suatu efek yang beroperasi pada subset tertentu dari Qubit; tipe `**operation**` yang paling umum adalah `**GateOperation**`.

#### Kubit

Kubit merupakan unit dasar dari informasi kuantum, Kubit atau bit kuantum (bahasa Inggris: *qubit* atau *quantum bit*): sebuah sistem dua tingkat yang berada dalam superposisi dari dua keadaan yang mungkin tersebut. Cirq juga mendukung sistem dimensional yang lebih tinggi yang disebut **qudit**.

Dalam Cirq, sebuah kubit tidak lain adalah sebuah objek abstrak yang memiliki sebuah *identifier*, `cirq.Qid` dan beberapa metadata potensial lainnya untuk menyatakan sifat-sifat spesifik perangkat yang dapat digunakan untuk memvalidasi suatu sirkuit. Lain halnya dengan qubit yang sebenarnya, kubit dalam Cirq tidak memiliki keadaan (*state*) apa pun. Alasannya adalah karena keadaan yang sebenarnya dari qubit dipertahankan dalam prosesor kuantum, atau, dalam kasus simulasi, berada dalam vektor keadaan yang disimulasikan.

Terdapat 3 tipe qubit utama yang ada dalam Cirq:

* `cirq.NamedQubit` - sebuah kubit abstrak yang hanya punya satu nama, tidak ada yang lain. Tipe ini digunakan untuk melabeli kubit menggunakan nama abstrak dan jika pemrogram tidak perlu membuat banyak kubit.
* `cirq.LineQubit` - sebuah kubit yang diidentifikasi dengan sebuah indeks integer dalam satu baris. Beberapa perangkat memiliki berbaris-baris kubit, sehingga `LineQubit` dapat digunakan untuk merepresentasikannya. `cirq.LineQubit.Range(3)` merupakan cara yang mudah untuk membuat 3 kubit.
* `cirq.GridQubit` - sebuah kubit yang ditempatkan pada sebuah grid dan diidentifikasi dengan koordinat 2D. Kebanyakan chip Google dinyatakan menggunakan `GridQubit` s.

Berikut beberapa contoh untuk menentukan setiap tipe kubit.

```
# Using named qubits can be useful for abstract algorithms
# as well as algorithms not yet mapped onto hardware.
q0 = cirq.NamedQubit('source')
q1 = cirq.NamedQubit('target')

# Line qubits can be created individually
q3 = cirq.LineQubit(3)

# Or created in a range
# This will create LineQubit(0), LineQubit(1), LineQubit(2)
q0, q1, q2 = cirq.LineQubit.range(3)

# Grid Qubits can also be referenced individually
q4\_5 = cirq.GridQubit(4, 5)

# Or created in bulk in a square
# This will create 16 qubits from (0,0) to (3,3)
qubits = cirq.GridQubit.square(4)

```
Beberapa penyedia komputasi kuantum menyediakan tipe kubitnya sendiri. Contohnya, Pasqal menetapkan `TwoDQubit` dan `ThreeDQubit` untuk menyatakan topologi spesifik dari atom netral saat memvalidasi sirkuit-sirkuit.

#### Gate

Gate merupakan efek yang dapat diterapkan pada sekumpulan kubit (objek-objek dengan sebuah `Qid`). `Gates` dapat diaplikasikan terhadap kubit-kubit dengan memanggil metode `on` mereka, atau, secara alternatif memanggil *gate* yang ada pada kubit. Objek yang dibuat oleh panggilan-panggilan semacam itu disebut sebagai sebuah `operation`. Alternatifnya, sebuah `gate` dapat dianggap sebagai sebuah pabrik yang, dengan kubit input yang telah disebutkan, menghasilkan sebuah objek `GateOperation` yang terkait.

Cirq mendukung sejumlah *gate*, dengan peluang untuk memperbanyak *gate-gate* yang tersedia untuk kasus penggunaan lanjutan.

Contoh operasi yang dapat dilakukan pada *gate* dan *operation*:

```
# Example gates
cnot\_gate = cirq.CNOT
pauli\_z = cirq.Z

# Use exponentiation to get square root gates.
sqrt\_x\_gate = cirq.X\*\*0.5

# Some gates can also take parameters
sqrt\_sqrt\_y = cirq.YPowGate(exponent=0.25)

# Create two qubits at once, in a line.
q0, q1 = cirq.LineQubit.range(2)

# Example operations
z\_op = cirq.Z(q0)
not\_op = cirq.CNOT(q0, q1)
sqrt\_iswap\_op = cirq.SQRT\_ISWAP(q0, q1)

# You can also use the gates you specified earlier.
cnot\_op = cnot\_gate(q0, q1)
pauli\_z\_op = pauli\_z(q0)
sqrt\_x\_op = sqrt\_x\_gate(q0)
sqrt\_sqrt\_y\_op = sqrt\_sqrt\_y(q0)

```

#### Sirkuit dan perangkat

Satu hal penting yang harus dipertimbangkan saat menggunakan perangkat kuantum yang sebenarnya adalah bahwa sering kali terdapat keterbatasan mengenai sirkuit-sirkuit yang dapat dijalankan pada perangkat keras tertentu. Objek `Device` digunakan untuk menetapkan batasan-batasan tersebut dan dapat digunakan untuk memvalidasi sirkuit guna memastikan bahwa sirkuit tersebut tidak berisi operasi-operasi ilegal.

Berikut merupakan contoh yang mendemonstrasikan hal tersebut dengan Perangkat Sycamore:

```
# Create some qubits.
q0 = cirq.GridQubit(5, 6)
q1 = cirq.GridQubit(5, 5)
q2 = cirq.GridQubit(4, 5)

# Create operations using the Sycamore gate, which is supported by the Sycamore device.
# However, create operations for both adjacent and non-adjacent qubit pairs.
adjacent\_op = cirq\_google.SYC(q0, q1)
nonadjacent\_op = cirq\_google.SYC(q0, q2)

# A working circuit for the Sycamore device raises no issues.
working\_circuit = cirq.Circuit()
working\_circuit.append(adjacent\_op)
valid = cirq\_google.Sycamore.validate\_circuit(working\_circuit)

# A circuit using invalid operations.
bad\_circuit = cirq.Circuit()
bad\_circuit.append(nonadjacent\_op)
try:
    cirq\_google.Sycamore.validate\_circuit(bad\_circuit)
except ValueError as e:
    print(e)

```
memberikan *output*:

```
Qubit pair is not valid on device: (cirq.GridQubit(5, 6), cirq.GridQubit(4, 5)).

```

#### Simulasi

Hasil dari pengaplikasian sirkuit kuantum dapat dihitung menggunakan sebuah `Simulator`. Cirq dibundel dengan simulator yang dapat menghitung hasil-hasil sirkuit hingga batas sekitar 20 kubit. Simulasi dapat diinisialisasi dengan `cirq.Simulator()`.

Terdapat dua pendekatan berbeda dalam menggunakan sebuah simulator:

* `simulate()`: Secara klasik, saat menyimulasikan suatu sirkuit, suatu simulator dapat secara langsung mengakses dan melihat fungsi gelombang yang dihasilkan. Hal ini berguna untuk debugging, pembelajaran, dan pemahaman terhadap cara sirkuit akan berfungsi.
* `run()`: Saat menggunakan perangkat kuantum yang sebenarnya, kita hanya dapat mengakses hasil akhir dari suatu komputasi dan harus mengambil sampel hasilnya untuk mendapatkan distribusi hasil.

Contoh kode
-----------

Berikut adalah contoh yang menunjukkan cara membuat dan mengukur Bell state dalam Cirq:

```
import cirq

# Pick a qubit.
qubit = cirq.GridQubit(0, 0)

# Create a circuit
circuit = cirq.Circuit(
    cirq.X(qubit)\*\*0.5,  # Square root of NOT.
    cirq.measure(qubit, key='m')  # Measurement.
)
print("Circuit:")
print(circuit)

# Simulate the circuit several times.
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=20)
print("Results:")
print(result)

```
Keluaran atau *output* dari kode di atas:

```
Circuit:
(0, 0): ───X^0.5───M('m')───
Results:
m=11000111111011001000

```

Lihat pula
----------

* Qiskit
* Python (bahasa pemrograman)

Pranala luar
------------

* (Inggris) Situs web resmi Cirq
* Repositori Cirq di GitHub
* (Inggris) Situs web resmi Google Quantum AI

Referensi
---------

1. ↑  MichaelBroughton. "Release Cirq v1.0.0 · quantumlib/Cirq". *GitHub*. Diakses tanggal 21 Maret 2023.
2. ↑  tanujkhattar. "Releases · quantumlib/Cirq". *GitHub*. Diakses tanggal 21 Maret 2023.
3. ↑  "Cirq/LICENSE at master · quantumlib/Cirq · GitHub". *GitHub*. Diakses tanggal 23 Maret 2023.
4. ↑  "Cirq". *Google Quantum AI* (dalam bahasa Inggris). Diakses tanggal 2023-03-21.
5. ↑  "Announcing Cirq: An Open Source Framework for NISQ Algorithms". *ai.googleblog.com* (dalam bahasa Inggris). Diakses tanggal 6 Maret 2019.
6. ↑  "public\_demos/max\_cut\_cirq.py at master · qcware/public\_demos · GitHub"". *GitHub*. Diarsipkan dari versi asli tanggal 20 Juli 2018. Diakses tanggal 29 Oktober 2019.
7. ↑  "Build a circuit | Cirq". *Google Quantum AI* (dalam bahasa Inggris). Diakses tanggal 2023-03-23.
8. ↑  "Circuits | Cirq". *Google Quantum AI* (dalam bahasa Inggris). Diakses tanggal 2023-03-23.
9. 1 2 3 4  "Cirq basics". *Google Quantum AI* (dalam bahasa Inggris). Diakses tanggal 2023-03-23.
10. ↑  "Gates and operations | Cirq". *Google Quantum AI* (dalam bahasa Inggris). Diakses tanggal 2023-03-23.
11. ↑  "Cirq | Google Quantum AI". *Google Quantum AI* (dalam bahasa Inggris). Diakses tanggal 21 Maret 2023.
12. ↑  *quantumlib/Cirq*, 2023-03-23, diakses tanggal 2023-03-23