Cirq

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

 Pranala luar 

  Situs web resmi Cirq
 Repositori Cirq di GitHub
  Situs web resmi Google Quantum AI

 Referensi 

Kategori:Pemrograman kuantum
Kategori:Pustaka Python
Kategori:Pustaka perangkat lunak
Kategori:Komputasi kuantum
Kategori:Proyek Google