# Quantum software

## Qiskit

Python library, claims multiple backends, including simulation and real IBM quantum computer.

## Qiskit hello world

Our version at qiskit/hello.py.

## @cirosantilli/_file/qiskit/qiskit/hello.py

Our example uses a Bell state circuit to illustrate all the fundamental Qiskit basics.
Sample program output, counts are randomized each time.
First we take the quantum state vector immediately after the input.
input:
state:
Statevector([1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
dims=(2, 2))
probs:
[1. 0. 0. 0.]
We understand that the first element of Statevector is , and has probability of 1.0.
Next we take the state after a Hadamard gate on the first qubit:
h:
state:
Statevector([0.70710678+0.j, 0.70710678+0.j, 0.        +0.j,
0.        +0.j],
dims=(2, 2))
probs:
[0.5 0.5 0.  0. ]
We now understand that the second element of the Statevector is , and now we have a 50/50 propabability split for the first bit.
Then we apply the CNOT gate:
cx:
state:
Statevector([0.70710678+0.j, 0.        +0.j, 0.        +0.j,
0.70710678+0.j],
dims=(2, 2))
probs:
[0.5 0.  0.  0.5]
which leaves us with the final .
Then we print the circuit a bit:
qc without measure:
┌───┐
q_0: ┤ H ├──■──
└───┘┌─┴─┐
q_1: ─────┤ X ├
└───┘
c: 2/══════════

qc with measure:
┌───┐     ┌─┐
q_0: ┤ H ├──■──┤M├───
└───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
└───┘ ║ └╥┘
c: 2/═══════════╩══╩═
0  1
qasm:
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q[0];
cx q[0],q[1];
measure q[0] -> c[0];
measure q[1] -> c[1];
And finally we compile the circuit and do some sample measurements:
qct:
┌───┐     ┌─┐
q_0: ┤ H ├──■──┤M├───
└───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
└───┘ ║ └╥┘
c: 2/═══════════╩══╩═
0  1
counts={'11': 484, '00': 516}
counts={'11': 493, '00': 507}

## qiskit/initialize.py

In this example we will initialize a quantum circuit with a single CNOT gate and see the output values.
By default, Qiskit initializes every qubit to 0 as shown in the qiskit/hello.py. But we can also initialize to arbitrary values as would be done when computing the output for various different inputs.
Output:
     ┌──────────────────────┐
q_0: ┤0                     ├──■──
│  Initialize(1,0,0,0) │┌─┴─┐
q_1: ┤1                     ├┤ X ├
└──────────────────────┘└───┘
c: 2/═════════════════════════════

init: [1, 0, 0, 0]
probs: [1. 0. 0. 0.]

init: [0, 1, 0, 0]
probs: [0. 0. 0. 1.]

init: [0, 0, 1, 0]
probs: [0. 0. 1. 0.]

init: [0, 0, 0, 1]
probs: [0. 1. 0. 0.]

┌──────────────────────────────────┐
q_0: ┤0                                 ├──■──
│  Initialize(0.70711,0,0,0.70711) │┌─┴─┐
q_1: ┤1                                 ├┤ X ├
└──────────────────────────────────┘└───┘
c: 2/═════════════════════════════════════════

init: [0.7071067811865475, 0, 0, 0.7071067811865475]
probs: [0.5 0.5 0.  0. ]
which we should all be able to understand intuitively given our understanding of the CNOT gate and quantum state vectors.
quantumcomputing.stackexchange.com/questions/13202/qiskit-initializing-n-qubits-with-binary-values-0s-and-1s describes how to initialize circuits qubits only with binary 0 or 1 to avoid dealing with the exponential number of elements of the quantum state vector.

## @cirosantilli/_file/qiskit/qiskit/qft.py

This is an example of the qiskit.circuit.library.QFT implementation of the Quantum Fourier transform function which is documented at: docs.quantum.ibm.com/api/qiskit/0.44/qiskit.circuit.library.QFT
Output:
init: [1, 0, 0, 0, 0, 0, 0, 0]
qc
┌──────────────────────────────┐┌──────┐
q_0: ┤0                             ├┤0     ├
│                              ││      │
q_1: ┤1 Initialize(1,0,0,0,0,0,0,0) ├┤1 QFT ├
│                              ││      │
q_2: ┤2                             ├┤2     ├
└──────────────────────────────┘└──────┘
transpiled qc
┌──────────────────────────────┐                                     ┌───┐
q_0: ┤0                             ├────────────────────■────────■───────┤ H ├─X─
│                              │              ┌───┐ │        │P(π/2) └───┘ │
q_1: ┤1 Initialize(1,0,0,0,0,0,0,0) ├──────■───────┤ H ├─┼────────■─────────────┼─
│                              │┌───┐ │P(π/2) └───┘ │P(π/4)                │
q_2: ┤2                             ├┤ H ├─■─────────────■──────────────────────X─
└──────────────────────────────┘└───┘
Statevector([0.35355339+0.j, 0.35355339+0.j, 0.35355339+0.j,
0.35355339+0.j, 0.35355339+0.j, 0.35355339+0.j,
0.35355339+0.j, 0.35355339+0.j],
dims=(2, 2, 2))

init: [0.0, 0.35355339059327373, 0.5, 0.3535533905932738, 6.123233995736766e-17, -0.35355339059327373, -0.5, -0.35355339059327384]
Statevector([ 7.71600526e-17+5.22650714e-17j,
1.86749130e-16+7.07106781e-01j,
-6.10667421e-18+6.10667421e-18j,
1.13711443e-16-1.11022302e-16j,
2.16489014e-17-8.96726857e-18j,
-5.68557215e-17-1.11022302e-16j,
-6.10667421e-18-4.94044770e-17j,
-3.30200457e-16-7.07106781e-01j],
dims=(2, 2, 2))
So this also serves as a more interesting example of quantum compilation, mapping the QFT gate to Qiskit Aer primitives.
If we don't transpile in this example, then running blows up with:
qiskit_aer.aererror.AerError: 'unknown instruction: QFT'
The second input is:
and the output of that approximately:
[0, 1j/sqrt(2), 0, 0, 0, 0, 0, 1j/sqrt(2)]
which can be defined simply as the normalized DFT of the input quantum state vector.

## qiskit.transpile()

This function does quantum compilation. Shown e.g. at qiskit/qft.py.

## AerError: 'unknown instruction

You get an error like this if you forget to call qiskit.transpile():
qiskit_aer.aererror.AerError: 'unknown instruction: QFT'
Related: quantumcomputing.stackexchange.com/questions/34396/aererror-unknown-instruction-c-unitary-while-using-control-unitary-operator/35132#35132

## Quantum circuit description language

These are a bit like the Verilog of quantum computing.
One would hope that they are not Turing complete, this way they may serve as a way to pass on data in such a way that the receiver knows they will only be doing so much computation in advance to unpack the circuit. So it would be like JSON is for JavaScript.

## OpenQASM

On Qiskit qiskit==0.44.1:
qc.qasm()
E.g. with our qiskit/hello.py, we obtain the Bell state circuit:
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q[0];
cx q[0],q[1];
measure q[0] -> c[0];
measure q[1] -> c[1];

## Quantum control system

Some people call it "operating System".
The main parts of those systems are:
• sending multiple signals at very precise times to the system
• reading out some quantum error correction bits and sending error correcting signals back in a control loop

## Quantum control systems use FPGAs

It seems that all/almost all of them do. Quite cool.

## Riverlane (2017)

When you fail a HR interview, then you know you've reached rock bottom.
Investments:

## Deltaflow.OS

A "quantum computer operating system". Or in English, control system + quantum error correction.
uknqt.ukri.org/wp-content/uploads/2021/10/UKNQTP-Strategic-Intent-2020.pdf page 24 mentions UKNQTP investment and gives an overview of some layers.