Pendahuluan

Komputasi kuantum sering terdengar seperti wilayah yang jauh: penuh simbol, perangkat laboratorium, dan istilah yang seolah hanya cocok dibaca setelah seseorang menjadi fisikawan teoretis. Buku ini mengambil jalan berbeda. Kita akan mempelajari komputasi kuantum sebagai sesuatu yang dapat dibangun pelan-pelan: dari bilangan kompleks, vektor, matriks, lalu menjadi gerbang, sirkuit, simulator, dan akhirnya algoritma.

Kata kuncinya adalah dibangun. Bukan sekadar digunakan.

Framework seperti Qiskit dan PennyLane1 sangat berguna. Namun, jika kita langsung memakainya tanpa memahami apa yang terjadi di bawahnya, sirkuit kuantum mudah terasa seperti kumpulan mantra: tulis H, tulis CX, panggil measure, lalu berharap hasilnya benar. Buku ini mengajak Anda membuka kotak hitam itu. Kita akan membuat laboratorium kecil dengan Python murni, sehingga setiap amplitudo, matriks gerbang, pengukuran, dan probabilitas dapat dilihat sebagai objek yang jelas.

Tujuan utamanya bukan menggantikan framework besar. Tujuan buku ini adalah membuat Anda cukup paham sehingga saat kelak memakai framework besar, Anda tahu apa yang sedang dilakukan oleh abstraksi tersebut.

Mengapa komputasi kuantum perlu dipelajari dari dasar?

Komputer klasik menyimpan informasi dalam bit. Bit adalah satuan informasi yang hanya memiliki dua nilai, biasanya ditulis sebagai 0 atau 1. Semua file, gambar, video, program, dan model kecerdasan buatan yang berjalan di komputer biasa pada akhirnya direpresentasikan melalui susunan bit.

Komputer kuantum menggunakan satuan informasi yang disebut qubit, singkatan dari quantum bit. Qubit juga memiliki dua keadaan basis yang biasa ditulis sebagai \(|0\rangle\) dan \(|1\rangle\). Namun, keadaan umum satu qubit bukan hanya “0 atau 1”. Secara matematis, keadaan satu qubit dapat ditulis sebagai

\[ |\psi\rangle = \alpha |0\rangle + \beta |1\rangle, \]

dengan \(\alpha\) dan \(\beta\) adalah bilangan kompleks yang disebut amplitudo. Bilangan kompleks adalah bilangan yang memiliki bagian real dan bagian imajiner, misalnya \(3 + 2i\), dengan \(i^2 = -1\). Dalam komputasi kuantum, amplitudo bukan probabilitas langsung. Probabilitas diperoleh dari kuadrat modulus amplitudo. Jika keadaan qubit adalah \(\alpha|0\rangle+\beta|1\rangle\), maka probabilitas memperoleh hasil pengukuran \(0\) adalah \(|\alpha|^2\), sedangkan probabilitas memperoleh hasil \(1\) adalah \(|\beta|^2\). Aturan ini dikenal sebagai aturan Born, dan merupakan salah satu postulat standar mekanika kuantum yang dipakai dalam model sirkuit kuantum modern (Nielsen & Chuang, 2010).

Sebagai contoh, keadaan

\[ |\psi\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle \]

memberi probabilitas

\[ \left|\frac{1}{\sqrt{2}}\right|^2 = \frac{1}{2} \]

untuk hasil \(0\), dan probabilitas yang sama untuk hasil \(1\). Jika keadaan ini diukur berulang kali pada banyak salinan identik, hasilnya tidak selalu 0 atau selalu 1, melainkan kira-kira separuh 0 dan separuh 1.

Perhatikan satu hal penting: qubit bukan “bit yang diam-diam menyimpan 0 dan 1 sekaligus” dalam arti klasik. Pernyataan seperti itu terlalu kasar dan sering menyesatkan. Yang benar: keadaan qubit direpresentasikan oleh vektor kompleks yang dapat berupa kombinasi linear dari keadaan basis. Kombinasi linear ini disebut superposisi. Ketika diukur pada basis tertentu, kita memperoleh satu hasil klasik menurut distribusi probabilitas yang ditentukan oleh amplitudo tersebut (Mermin, 2007).

Inilah alasan pertama mengapa komputasi kuantum perlu dipelajari dari dasar: intuisi klasik kita tidak cukup. Kita perlu membangun intuisi baru yang tetap matematis, tetapi tidak harus mistis.

Apa yang sebenarnya dihitung oleh komputer kuantum?

Dalam model sirkuit kuantum, komputasi digambarkan sebagai perubahan keadaan kuantum melalui rangkaian operasi. Operasi dasar ini disebut gerbang kuantum. Gerbang kuantum mirip dengan gerbang logika klasik dalam arti sama-sama mengubah informasi. Namun, gerbang kuantum yang ideal direpresentasikan oleh matriks uniter.

Matriks adalah susunan bilangan dalam baris dan kolom. Matriks uniter adalah matriks kompleks \(U\) yang memenuhi

\[ U^\dagger U = I, \]

dengan \(U^\dagger\) adalah transpose konjugat dari \(U\), dan \(I\) adalah matriks identitas. Secara intuitif, operasi uniter mempertahankan panjang vektor keadaan. Karena panjang vektor keadaan berkaitan dengan total probabilitas, sifat ini memastikan bahwa total probabilitas tetap \(1\). Sifat uniter merupakan bagian dari formulasi standar evolusi keadaan tertutup dalam mekanika kuantum dan menjadi dasar model sirkuit kuantum (Nielsen & Chuang, 2010).

Sebagai contoh, gerbang Pauli-X pada satu qubit direpresentasikan oleh matriks

\[ X = \begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix}. \]

Jika diterapkan pada \(|0\rangle\), hasilnya \(|1\rangle\). Jika diterapkan pada \(|1\rangle\), hasilnya \(|0\rangle\). Dalam hal ini, gerbang \(X\) berperilaku seperti NOT klasik. Tetapi gerbang yang sama juga dapat bekerja pada superposisi. Jika

\[ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle, \]

maka

\[ X|\psi\rangle = \beta|0\rangle + \alpha|1\rangle. \]

Jadi, gerbang kuantum bukan hanya memetakan 0 menjadi 1 dan 1 menjadi 0; ia memetakan seluruh vektor amplitudo menjadi vektor amplitudo baru.

Di sinilah Python murni menjadi sangat berguna. Kita dapat merepresentasikan keadaan \(|0\rangle\) sebagai daftar:

zero = [1+0j, 0+0j]

dan keadaan \(|1\rangle\) sebagai:

one = [0+0j, 1+0j]

Gerbang \(X\) dapat direpresentasikan sebagai daftar bersarang:

X = [
    [0+0j, 1+0j],
    [1+0j, 0+0j],
]

Lalu kita dapat menulis sendiri fungsi perkalian matriks-vektor. Tidak ada sihir. Tidak ada backend tersembunyi. Hanya aljabar linear yang bekerja secara jujur.

Mengapa amplitudo kompleks begitu penting?

Jika probabilitas hasil pengukuran hanya diperoleh dari \(|\alpha|^2\), mengapa kita tidak langsung memakai probabilitas saja?

Jawabannya: karena amplitudo dapat berinterferensi.

Interferensi adalah peristiwa ketika kontribusi amplitudo dari beberapa jalur komputasi bergabung. Jika amplitudo memiliki fase yang cocok, amplitudo dapat saling memperkuat. Ini disebut interferensi konstruktif. Jika amplitudo memiliki fase berlawanan, amplitudo dapat saling menghapus. Ini disebut interferensi destruktif. Interferensi amplitudo adalah salah satu mekanisme inti yang membuat algoritma kuantum berbeda dari algoritma probabilistik klasik biasa (Nielsen & Chuang, 2010).

Contoh sederhana dapat dilihat melalui gerbang Hadamard. Gerbang Hadamard, ditulis \(H\), didefinisikan sebagai

\[ H = \frac{1}{\sqrt{2}} \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix}. \]

Gerbang ini mengubah \(|0\rangle\) menjadi

\[ H|0\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle. \]

Jika kita menerapkan Hadamard sekali lagi, hasilnya kembali ke \(|0\rangle\):

\[ H(H|0\rangle)=|0\rangle. \]

Ini bukan sekadar “acak lalu acak lagi”. Jika Hadamard pertama dianggap membuat peluang 50–50, Hadamard kedua tidak menghasilkan peluang 50–50 lagi, melainkan mengembalikan keadaan secara pasti ke \(|0\rangle\). Mengapa? Karena amplitudo untuk \(|1\rangle\) saling menghapus, sedangkan amplitudo untuk \(|0\rangle\) saling memperkuat.

Fenomena seperti inilah yang akan kita pelajari berulang kali. Algoritma kuantum yang penting tidak bekerja karena “mencoba semua jawaban secara paralel lalu membaca semuanya”. Pernyataan itu tidak benar. Pengukuran hanya memberi satu hasil klasik. Algoritma kuantum dirancang agar amplitudo jawaban yang salah saling melemah, sementara amplitudo jawaban yang benar diperkuat.

Dari ide fisis ke model komputasi

Komputasi kuantum lahir dari pertanyaan yang sangat alami: jika alam pada skala mikroskopis mengikuti mekanika kuantum, apakah komputer yang memanfaatkan hukum kuantum dapat mensimulasikan sistem kuantum dengan lebih alami daripada komputer klasik? Richard Feynman mengemukakan gagasan bahwa simulasi sistem kuantum secara umum tampak tidak efisien jika dipaksakan pada komputer klasik, dan bahwa komputer berbasis prinsip kuantum dapat menjadi pendekatan yang lebih sesuai untuk tugas tersebut (Feynman, 1982). David Deutsch kemudian merumuskan gagasan komputer kuantum universal dalam kerangka teori komputasi, menghubungkan mekanika kuantum dengan prinsip komputasi universal (Deutsch, 1985).

Dari sana, bidang ini berkembang bukan hanya sebagai cara mensimulasikan sistem fisis kuantum, tetapi juga sebagai model komputasi dengan algoritma khasnya sendiri. Peter Shor menemukan algoritma kuantum untuk faktorisasi bilangan bulat dan logaritma diskret yang berjalan dalam waktu polinomial pada model kuantum ideal, suatu hasil yang mengguncang kriptografi berbasis kesulitan faktorisasi (Shor, 1994). Lov Grover kemudian memperkenalkan algoritma pencarian kuantum yang memberikan percepatan kuadratik untuk pencarian tak terstruktur (Grover, 1996).

Namun, penting untuk menjaga ekspektasi tetap benar. Komputer kuantum tidak otomatis lebih cepat untuk semua masalah. Keunggulan kuantum bergantung pada struktur masalah, model akses data, rancangan algoritma, serta keterbatasan perangkat. Banyak komputasi biasa tetap lebih cocok dijalankan pada komputer klasik. Buku ini tidak akan menjual komputasi kuantum sebagai keajaiban universal. Kita akan mempelajarinya sebagai model komputasi yang kuat, indah, dan spesifik.

Mengapa Python murni?

Python murni dalam buku ini berarti kita akan mengutamakan fitur dasar Python: angka kompleks, daftar, fungsi, kelas sederhana, dan modul standar jika diperlukan. Kita tidak akan bergantung pada NumPy, Qiskit, PennyLane, Cirq, atau framework kuantum lain pada bagian-bagian fondasi.

Mengapa tidak langsung memakai NumPy? NumPy sangat baik untuk komputasi numerik. Namun, pada tahap awal, menggunakan daftar dan loop sendiri memaksa kita melihat struktur perhitungan. Misalnya, saat menerapkan gerbang satu qubit pada register tiga qubit, kita harus memahami bagaimana indeks basis biner bekerja. Keadaan \(|101\rangle\) tidak hanya simbol; dalam simulator vektor keadaan, ia berkaitan dengan posisi tertentu dalam daftar amplitudo.

Untuk tiga qubit, ada \(2^3 = 8\) keadaan basis komputasional:

\[ |000\rangle,\ |001\rangle,\ |010\rangle,\ |011\rangle,\ |100\rangle,\ |101\rangle,\ |110\rangle,\ |111\rangle. \]

Maka vektor keadaan memiliki 8 amplitudo. Untuk \(n\) qubit, vektor keadaan memiliki \(2^n\) amplitudo. Pertumbuhan eksponensial ini adalah alasan mengapa simulasi klasik penuh terhadap sistem banyak qubit cepat menjadi mahal. Fakta bahwa ruang keadaan sistem kuantum komposit tumbuh secara eksponensial terhadap jumlah subsistem merupakan salah satu alasan utama komputasi kuantum menarik sekaligus sulit disimulasikan secara klasik (Nielsen & Chuang, 2010).

Contoh kecilnya:

# keadaan |000> untuk 3 qubit
state = [0j] * 8
state[0] = 1 + 0j

Keadaan \(|101\rangle\) memiliki representasi biner 101, yaitu bilangan desimal 5. Maka:

# keadaan |101> untuk 3 qubit
state = [0j] * 8
state[5] = 1 + 0j

Hal sederhana seperti ini sangat penting. Banyak kebingungan dalam komputasi kuantum bukan berasal dari rumus yang terlalu sulit, tetapi dari tidak jelasnya hubungan antara simbol matematika, struktur data, dan operasi program.

Buku ini akan terus menjembatani tiga dunia itu:

1. simbol matematika,
2. makna komputasional,
3. implementasi Python.

Apa yang akan Anda bangun?

Buku ini dirancang agar Anda tidak hanya membaca definisi, tetapi membangun alat berpikir.

Pada awal buku, kita akan memperkuat fondasi aljabar linear yang benar-benar dipakai: vektor, matriks, basis, hasil kali dalam, norma, nilai eigen, vektor eigen, matriks Hermitian, dan matriks uniter. Kita tidak akan membahas aljabar linear sebagai katalog rumus, tetapi sebagai bahasa kerja komputasi kuantum.

Setelah itu, kita masuk ke bilangan kompleks, amplitudo, probabilitas, dan notasi Dirac. Notasi Dirac adalah cara penulisan vektor dan kovektor yang umum dalam mekanika kuantum. Simbol \(|\psi\rangle\) disebut ket, sedangkan \(\langle\psi|\) disebut bra. Jika keduanya digabung, kita memperoleh objek seperti \(\langle\phi|\psi\rangle\), yaitu hasil kali dalam antara dua keadaan. Notasi ini sangat ringkas, tetapi akan terasa sulit jika tidak dihubungkan dengan vektor dan matriks biasa. Karena itu, setiap notasi akan kita sambungkan dengan representasi Python.

Kemudian kita mempelajari qubit tunggal, bola Bloch, dan gerbang satu qubit. Bola Bloch adalah representasi geometris untuk keadaan murni satu qubit, dengan catatan bahwa keadaan global yang hanya berbeda fase global merepresentasikan keadaan fisis yang sama. Misalnya, \(|\psi\rangle\) dan \(e^{i\theta}|\psi\rangle\) memberi probabilitas pengukuran yang sama untuk semua pengukuran, sehingga fase global tidak dapat diamati secara langsung dalam keadaan tersebut (Mermin, 2007).

Setelah pengukuran dan sistem banyak qubit, kita akan membangun simulator vektor keadaan. Simulator ini akan mampu menerapkan gerbang pada qubit target, menangani gerbang terkontrol, membentuk keterjeratan, dan melakukan sampling hasil pengukuran. Keterjeratan adalah korelasi kuantum antara subsistem yang tidak dapat dijelaskan dengan menyatakan masing-masing subsistem memiliki keadaan murni sendiri-sendiri. Contoh paling terkenal adalah keadaan Bell:

\[ |\Phi^+\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle). \]

Keadaan ini bukan sekadar “dua bit acak yang sama”. Ia adalah keadaan gabungan dua qubit yang tidak dapat dipisahkan menjadi hasil kali tensor dari keadaan qubit pertama dan keadaan qubit kedua. Keterjeratan adalah salah satu ciri paling khas mekanika kuantum dan memainkan peran penting dalam banyak protokol informasi kuantum (Nielsen & Chuang, 2010).

Setelah fondasi simulator siap, kita akan masuk ke algoritma: Deutsch, Deutsch-Jozsa, Bernstein-Vazirani, Simon, Quantum Fourier Transform, Quantum Phase Estimation, inti algoritma Shor, dan Grover. Setiap algoritma akan dilihat bukan sebagai resep hafalan, tetapi sebagai rancangan interferensi amplitudo.

Di bagian akhir, kita memperluas pandangan ke matriks densitas dan derau, universalitas gerbang, kompilasi sirkuit, algoritma variasional, lalu jembatan menuju Qiskit dan PennyLane. Dengan demikian, saat Anda berpindah ke framework besar, istilah seperti backend, transpilation, ansatz, Hamiltonian, expectation value, shot, dan noise model tidak lagi terasa asing.

Cara berpikir yang akan kita latih

Ada tiga kebiasaan berpikir yang akan sering muncul dalam buku ini.

Pertama, kita akan selalu bertanya: apa representasi matematisnya? Jika ada qubit, kita tanya vektornya. Jika ada gerbang, kita tanya matriksnya. Jika ada pengukuran, kita tanya probabilitasnya.

Kedua, kita akan bertanya: apa struktur datanya? Vektor keadaan menjadi daftar bilangan kompleks. Matriks menjadi daftar bersarang. Sirkuit menjadi urutan operasi. Hasil pengukuran menjadi sampel acak dari distribusi probabilitas.

Ketiga, kita akan bertanya: apa yang dapat diuji? Dalam komputasi kuantum, intuisi saja tidak cukup. Kita perlu memverifikasi normalisasi, memeriksa apakah matriks uniter, membandingkan probabilitas teoretis dengan frekuensi sampling, dan menguji apakah hasil simulator sesuai dengan perhitungan manual.

Sebagai contoh, jika sebuah keadaan ditulis:

\[ |\psi\rangle = \frac{1}{2}|0\rangle + \frac{\sqrt{3}}{2}|1\rangle, \]

maka sebelum melakukan hal lain, kita periksa normalisasi:

\[ \left|\frac{1}{2}\right|^2 + \left|\frac{\sqrt{3}}{2}\right|^2 = \frac{1}{4} + \frac{3}{4} = 1. \]

Karena total probabilitasnya \(1\), keadaan ini valid sebagai keadaan kuantum satu qubit. Dalam Python, pemeriksaan seperti ini dapat dibuat menjadi fungsi kecil. Kebiasaan sederhana ini akan mencegah banyak kesalahan.

Buku ini bukan tentang menghafal gerbang

Anda mungkin pernah melihat daftar gerbang kuantum: \(X\), \(Y\), \(Z\), \(H\), \(S\), \(T\), CNOT, CZ, SWAP, Toffoli, dan seterusnya. Daftar itu penting, tetapi bukan inti terdalam dari belajar komputasi kuantum.

Yang lebih penting adalah memahami pola berikut:

1. keadaan direpresentasikan oleh vektor amplitudo kompleks;
2. gerbang ideal direpresentasikan oleh matriks uniter;
3. rangkaian gerbang adalah komposisi operasi linear;
4. pengukuran mengubah amplitudo menjadi probabilitas hasil klasik;
5. algoritma kuantum merancang interferensi agar hasil yang diinginkan lebih mungkin muncul.

Jika lima gagasan ini menjadi jelas, gerbang-gerbang kuantum tidak lagi terasa seperti simbol asing. Mereka menjadi alat.

Sebagai analogi, belajar komputasi kuantum hanya dengan menghafal gerbang mirip dengan belajar pemrograman hanya dengan menghafal nama fungsi. Anda mungkin tahu banyak nama, tetapi belum tentu dapat merancang program. Buku ini ingin membawa Anda dari “tahu nama gerbang” menuju “mampu merancang sirkuit dan memahami mengapa ia bekerja”.

Batasan yang sengaja kita terima

Karena buku ini menggunakan Python murni dan menekankan pemahaman dari nol, ada batasan yang perlu disadari.

Pertama, simulator vektor keadaan akan cepat menjadi lambat untuk jumlah qubit besar, karena jumlah amplitudo tumbuh sebagai \(2^n\). Sepuluh qubit masih ringan. Dua puluh qubit mulai terasa. Tiga puluh qubit sudah membutuhkan memori besar jika direpresentasikan penuh sebagai vektor keadaan kompleks. Ini bukan kelemahan Python semata, melainkan konsekuensi dari representasi eksplisit ruang keadaan.

Kedua, simulator awal kita akan menggambarkan komputer kuantum ideal. Artinya, gerbang dianggap sempurna dan tidak ada interaksi tak diinginkan dengan lingkungan. Dalam perangkat nyata, sistem kuantum mengalami derau dan dekoherensi. Dekoherensi adalah hilangnya koherensi fase akibat interaksi dengan lingkungan, yang membuat perilaku kuantum ideal sulit dipertahankan. Pada era perangkat kuantum skala menengah yang belum sepenuhnya tahan galat, derau menjadi faktor sentral dalam eksperimen dan aplikasi praktis (Preskill, 2018).

Ketiga, buku ini tidak akan langsung membahas semua detail perangkat keras kuantum. Kita akan menyentuh makna fisis qubit dan pengukuran seperlunya, tetapi fokus utama adalah model komputasi, matematika, dan simulasi sirkuit.

Batasan ini justru membantu. Dengan menyederhanakan lingkungan belajar, kita dapat melihat struktur dasar dengan jernih sebelum menghadapi kompleksitas perangkat nyata dan framework industri.

Hasil belajar yang diharapkan

Setelah menyelesaikan buku ini, Anda diharapkan mampu membaca sirkuit kuantum sederhana dan menjelaskan apa yang terjadi pada vektor keadaan. Anda juga diharapkan mampu menulis simulator kecil dari nol, bukan karena simulator itu akan mengalahkan framework profesional, tetapi karena proses menulisnya akan memaksa Anda memahami komputasi kuantum secara operasional.

Anda akan mampu menjawab pertanyaan seperti:

• Apa beda amplitudo dan probabilitas?
• Mengapa matriks gerbang kuantum harus uniter dalam model ideal?
• Bagaimana gerbang Hadamard menciptakan dan menghapus amplitudo?
• Bagaimana CNOT dapat membentuk keterjeratan?
• Mengapa pengukuran tidak sekadar membaca keadaan tanpa mengubahnya?
• Bagaimana orakel kuantum merepresentasikan fungsi klasik secara reversibel?
• Mengapa algoritma Deutsch-Jozsa, Bernstein-Vazirani, Simon, Shor, dan Grover dapat memperoleh keuntungan pada masalah tertentu?
• Mengapa simulasi banyak qubit sulit dilakukan secara klasik?
• Bagaimana konsep yang dibangun di Python murni muncul kembali dalam Qiskit dan PennyLane?

Jika pertanyaan-pertanyaan itu terasa besar sekarang, tidak masalah. Buku ini disusun agar kita menaiki tangganya satu per satu.

Titik awal kita

Kita akan mulai dari peta besar. Sebelum masuk ke rumus, kita perlu memahami medan yang akan dijelajahi: apa itu komputasi kuantum, mengapa amplitudo kompleks menjadi pusatnya, apa yang dimaksud dengan sirkuit kuantum, dan mengapa Python murni dapat menjadi laboratorium belajar yang efektif.

Setelah itu, kita akan memperkuat aljabar linear yang benar-benar dipakai. Tidak semua topik aljabar linear diperlukan dengan kedalaman yang sama. Kita akan fokus pada bagian yang langsung muncul dalam komputasi kuantum: vektor, matriks, basis, hasil kali dalam, norma, eigenvektor, nilai eigen, matriks Hermitian, dan matriks uniter.

Pelan-pelan, simbol seperti

\[ |\psi\rangle,\quad U|\psi\rangle,\quad \langle\psi|\phi\rangle,\quad |\alpha|^2 \]

akan berubah dari tanda yang asing menjadi bahasa yang Anda gunakan untuk berpikir.

Itulah tujuan pendahuluan ini: bukan membuat komputasi kuantum tampak mudah secara palsu, tetapi membuatnya tampak dapat didekati secara benar. Komputasi kuantum memang menuntut ketelitian. Namun, dengan urutan belajar yang baik, contoh yang konkret, dan kode yang transparan, ia dapat dipahami jauh lebih manusiawi daripada yang sering dibayangkan.

Mari kita mulai dari peta besarnya.

References

Deutsch, D. (1985). Quantum theory, the Church-Turing principle and the universal quantum computer. Proceedings of the Royal Society of London. A. Mathematical and Physical Sciences, 400(1818), 97–117.

Feynman, R. P. (1982). Simulating physics with computers. International Journal of Theoretical Physics, 21(6/7), 467–488.

Grover, L. K. (1996). A fast quantum mechanical algorithm for database search. In Proceedings of the Twenty-Eighth Annual ACM Symposium on Theory of Computing (pp. 212–219).

Mermin, N. D. (2007). Quantum Computer Science: An Introduction. Cambridge University Press.

Nielsen, M. A., & Chuang, I. L. (2010). Quantum Computation and Quantum Information: 10th Anniversary Edition. Cambridge University Press.

Preskill, J. (2018). Quantum Computing in the NISQ era and beyond. Quantum, 2, 79.

Shor, P. W. (1994). Algorithms for quantum computation: discrete logarithms and factoring. In Proceedings 35th Annual Symposium on Foundations of Computer Science (pp. 124–134). IEEE.