This entry continues from installation of QuTiP.

1. Assuming the relevant conda environment is activated, as per official documentation, in the Conda command prompt, install qiskit and galois:

   pip install qiskit[visualization] qiskit-ibm-runtime galois

   galois is not necessary for qiskit but necessary for our courses.

   Qiskit usually uses NumPy of a lower version than what QuTiP uses, so expect existing NumPy to be downgraded.

2. Subsequently, as per official documentation, install the qiskit_textbook package:

   pip install git+https://github.com/qiskit-community/qiskit-textbook.git#subdirectory=qiskit-textbook-src

   Qiskit Textbook is a community project offering learning resources that will be useful to us.

3. Test Qiskit in a Python shell:

   The two commands in the screenshot above ☝ should not trigger any error.

4. Next, test Qiskit in JupyterLab. To launch JupyterLab, as per official documentation, open a Conda prompt (not Python shell) and type:

   jupyter lab

   Expect a web browser window to be launched, where you can create a new “Python 3 (ipykernel)” notebook:

   Note ipykernel is an interactive Python kernel for Jupyter.

   Copying the first piece of code from the “Introduction to Qiskit” tutorial and pasting it into the newly created “Python 3 (ipykernel)” notebook should produce the circuit diagram at the bottom of this screenshot:

Qiskit comes with a super-quick introduction to Python and Jupyter notebooks.

Visual Studio Code is a popular alternative to a web browser for hosting Jupyter notebooks, but to minimise the number of software components that can go wrong, we shall stick with a web browser (for which Mozilla Firefox is recommended).

The quantum bit error rate (QBER) is the error rate affecting two bitstrings obtained as a result of the same quantum measurement performed on two different sets of quantum systems [Gra21, p. xvi].

See BB84 to put this definition in context.

Creating a low voltage to represent a logical “0” and a high voltage to represent a logical “1” is straightforward.

🤷‍♂️ Creating a superposition of low and high voltages however is not.

A quantum computer is commonly envisioned to be a machine that exploits the full complexity of a many-particle quantum wavefunction to solve computational problems [LJL+10].

• The current state of quantum computing technologies is summarised by the keywords Noisy Intermediate-Scale Quantum (NISQ).
• NISQ computers are subject to substantial error rates and has a limited number of qubits [LLSK22, Sec. 1].

For the construction of quantum computers, laser serves as an inspiration because it is quantum mechanics that enables laser waves to be generated in phase [LJL+10].

Just as there are many possible materials for lasers (e.g., crystals, organic dye molecules, semiconductors, free electrons), there are many materials under consideration for quantum computers; see [LJL+10] and [MM12, Ch. 6].

Quantum bits are often imagined to be constructed from the smallest form of matter, e.g., an isolated atom, through ion traps and optical lattices, but they can also be made in components far larger than consumer electronics, e.g., a superconducting system [LJL+10].

Below we discuss three main technologies [LLSK22, Sec. 6]: 1️⃣ trapped ions, 2️⃣ photonics, and 3️⃣ superconducting qubits.

Photonics: Photonics has always been a prominent candidate for realising qubits [LLSK22].

For generating qubits, photonics offers the following advantages [SP19, PAB+20, LLSK22]:

• Photons are clean and decoherence-free quantum systems for which single-qubit operations can be easily performed with high fidelity, making photons a flagship system for studying quantum mechanics and developing quantum technologies.
• Quantum entanglement, teleportation, QKD, and early quantum computing demonstrations were pioneered in photonics because photons represent a naturally mobile and low-noise system with quantum-limited detection readily available.
• The quantum states of individual photons can be manipulated with high precision using interferometry, an experimental staple that has been under continuous development since the 19th century.
• The ability to generate large numbers of photons and the development of integrated platforms, improved sources and detectors, novel noise-tolerant theoretical approaches render photonics a leading contender for both quantum information processing and quantum networking.
• Nowadays, photonic quantum computing represents a promising path to medium- and large-scale processing.
• Photonics is the primary technology for realising quantum communications.

Superconducting qubits: They are currently the leading contenders in the race for large-scale quantum computing [LLSK22]. Superconducting qubits are the technology big-tech companies like Google and IBM have been focusing on.

In 2019, a large research team consisting of Google and multiple American and European universities demonstrated “quantum supremacy” on a programmable superconducting quantum processor called “Sycamore”, which consists of a two-dimensional array of 54 transmon qubits [AAB+19]:

• In the superconducting circuit of Sycamore, conduction electrons condense into a macroscopic quantum state, such that currents and voltages behave quantum-mechanically.
• Transmon is short for “transmission-line shunted plasma oscillation”.
• The employed transmon qubits can be thought of as nonlinear superconducting resonators at 5-7 GHz, and each qubit encodes the two lowest quantum eigenstates of the resonant circuit.
• Each qubit is connected to its four neighbouring qubits using an adjustable coupler for tuning inter-qubit coupling. 💡 Coupling qubits is essential for implementing two-qubit gates.
• Each qubit is also connected to a linear resonator used to read out the qubit state.
• Sycamore’s record might have been broken by China’s Zuchongzi in 2021 [Cho21].
• In 2023, Google demonstrated quantum supremacy again with an increased qubit count of 70 [MVM+23].
• IBM is slated to launch its 1121-bit NISQ computer called Condor.

There is no shortage of quantum computing frameworks/toolkits, including Google’s Cirq, Rigetti’s Forest SDK (including pyQuil), Microsoft’s Q#-based Quantum Development Kit, IBM’s Qiskit, Quipper, QuTiP, ETHZ’s Silq, Cambridge Quantum Computing’s tket.

We shall use Qiskit because 1️⃣ it is among the most well-established, and 2️⃣ it comes with rich learning resources.

• Qiskit is an open-source Python-based SDK created by IBM for working with quantum computers at the level of pulses, circuits, and application modules.

We shall also use QuTiP, because while Qiskit is popular for quantum computing, QuTiP offers more features for quantum-dynamical simulations.

• Simplistically speaking, Qiskit is more for computer scientists, whereas QuTiP is more for physicists.
• Unlike Qiskit, which uses quantum circuits (QuantumCircuit) as the main building blocks, QuTiP uses “quantum objects” (QObj).

Watch an introduction to QuTiP:

Using Qiskit and QuTiP means we are using Python but there are so many resources for learning Python it should not be an issue for a Bachelor/Master student to pick it up along the way.

Our strategy here is to first install QuTiP, then Qiskit.

The operating system of choice for many computer scientists and cryptograhers is Linux, but the setup guide here is only applicable to Windows, because UniSA computer pools have only Windows.

Follow the instructions below (derived from the official instructions) to set up QuTiP:

1. Install the Python distribution Miniconda, or Anaconda if you prefer installing more packages upfront.

   Upon successful installation of 64-bit Conda (short for “Miniconda/Anaconda”), you will see folder “Anaconda3 (64-bit)” on your Start menu, and under the folder, menu item “Anaconda Prompt (miniconda3)” 👈 Click this menu item to get a Conda command prompt.

   In the command prompt, run command to update Conda to the latest version:

   conda update conda

2. Upon successful update of conda, in command line, create a conda environment called cyber (which can otherwise be any name you fancy):

   conda create -n cyber

   Environment is an essential feature of Conda for creating sandboxes for prototyping, development and experimentation. Read this guide to get a better understanding of Conda environments, including how to create/activate/list/deactivate/remove environments.

   Upon successful creation of the environment cyber, activate it:

   conda activate cyber

3. Add the channel conda-forge to the list of channels (to be sure, keeping defaults at the highest priority) and install the necessary packages:

   conda config --append channels conda-forge
   conda install qutip pytest jupyterlab jupyterlab-git ipywidgets jupyterlab_widgets nodejs `
   seaborn numba numexpr pandas pandoc sympy

Above, the backtick (`) is the line continuation character in PowerShell.

Among the packages just installed,

• pytest is for automating testing of Python code (e.g., of QuTiP).
• jupyterlab is the JupyterLab package that will provide our graphical user interface (GUI).
• jupyterlab-git is for version-controlling Jupyter notebooks.
• ipywidgets and jupyterlab_widgets are libraries of Jupyter widgets.
• nodejs is cross-platform Javascript runtime environment useful for JupyterLab.
• seaborn is a Python data visualization library based on matplotlib.
• numpy is not shown above, but is automatically installed with qutip. This is the fundamental package for scientific computing with Python.
• numba is a just-in-time compiler that translates a subset of Python and NumPy code into fast machine code.
• numexpr is for accelerating numerical evaluation of expressions in NumPy.
• scipy is not shown above, but is automatically installed with qutip. This complements numpy for scientific computing with Python.
• pandas is a data analysis library.
• pandoc is a versatile document converter.
• sympy is a versatile computer algebra system for symbolic computing.
• pip is not shown above, but is a common dependency that is automatically installed by many other packages. It is a package installer for Python.

Official Conda documentation discourages using pip and conda together, but we need pip for Qiskit later.

4. Optional: Test your setup by running the official unit tests in a Python shell:

   import qutip.testing
   qutip.testing.run()

   These tests are computationally intensive and can slow down your computer dramatically. For reference, on a Intel Core i9-9880H CPU with 32 GB RAM, the tests take between 35 and 40 minutes.

5. Continue to installation of Qiskit.