Eunkwang Shin

주제 선정​

• 박사과정 4년 중 1.5년은 읽기만 해야한다.
• Area of Interest (AOI)는 내가 좋아하는 걸 해야 버틸 수 있다.
• 그리고 그 1.5년 뒤에는 Research Question이 나올 것이다.
• 4년 내의 논문에서 Future Work를 취합하자.

좋은 연구 주제​

• Government
  • Originality of content, document
  • How can differntiate from generated content?

Master leading to PhD​

• UTS: feature research students

논문​

• Abstract가 흥미있으면 Conclusion을 읽고, 그 다음 관련 내용이면 전체를 읽어야한다.
• 공식을 처음부터 이해하려고 하지 말자.
• 2022년 이후 (4개년까지만) 논문을 읽어야한다.
  • 왜냐면 박사과정이 4-5년이니까.

Computer Vision​

• Classification
• Classification with Localization
• Object Detection

Convolutional Neural Networks (CNN)​

1. Convolutional Layer (CONV)
2. Pooling Layer (POOL)
3. Fully Connected Layer (FC)

Convulutional Layer (CONV)​

• The first layer to extraact features from an input image
• Core buildling block of a CNN
• Convolutions are basic operation in this layer
• A number of filters (e.g. edge detectors) are applied to the input image.

Padding​

• Padding is used to control the spatial size of the output feature maps.
• Negative values at the edges can naturally arise because of padding, and they usually are not a big problem because activation functions and later layers come afterward.
• Input Matrix dimension: $n \times n \times c$ (height, width, channels)
• Filter size: $f \times f$
• Padding ($P$): 1, number of pixels added to the border of the input
• $(n \times n) * (f \times f) \to (n + 2P - f + 1) \times (n + 2P - f + 1)$
  • Example: $5 \times 5$ input with $3 \times 3$ filter and padding of 1 results in a $5 \times 5$ output feature map.
• if input and output matrix dimensions are the same, then $P = \frac{f - 1}{2}$.
• Valid padding ($P = 0$): No Padding
• Same padding ($P = \frac{f - 1}{2}$): Output size and input size is same, this requires appropriate padding.

Stride​

• It is the number of pixels by which slide the filter across the input image.

No Padding Strides	Stride with Padding

• Github: vdumoulin/conv_arithmetic
• Input Matrix dimension: $n \times n$
• Filter size: $f \times f$
• Padding: $P$
• Stride: $S$
• Output Size = $\left\lfloor \frac{n + 2P - f}{S} + 1 \right\rfloor \times \left\lfloor \frac{n + 2P - f}{S} + 1 \right\rfloor$
  • Example: Input Matrix dimension: $5 \times 5$, Filter size: $3 \times 3$, Padding: $1$, Stride: $2$ results in an output size of $2 \times 2$.

Pooling Layer (POOL)​

• Down sampling operation which reduces the dimensionality of a matrix.
• Reduces the number of parameters for large image, but retain the valuable information.
• Max pooling
• Average pooling
• Sum pooling

Fully Connected Layer (FC)​

• a traditional Multi-layer Perception (MLP) layer
• For multi-class classification, usually Softmax activation is used.
• Softmax ensures the output.
• Output of the CONV and POOL layers represent a high level features of the Input image.
• The FC layer takes these features to classify the input image into the desired output classes.

Logistic Regression as Neural Network​

• if $y = 1$
  • $L = -\log(\hat{y})$
  • if $\hat{y} \to 1$, then $L \to 0$ (low loss)
  • if $\hat{y} \to 0$, then $L \to \infty$ (high loss)
• if $y = 0$
  • $L = -\log(1 - \hat{y})$
  • if $\hat{y} \to 0$, then $L \to 0$ (low loss)
  • if $\hat{y} \to 1$, then $L \to \infty$ (high loss)

Gradient Descent​

• it is an iterative approach for error correction in a machene learning model
• Find $w$ and $b$ that will minimize $GD(w, b)$ (requires Loss/Cost function)

1. Initialize $w$ and $b$
2. Perform Forward pass operation/calculations
3. Compute Loss/Cost function $L(a, y)$
4. Compute change in $w$ and $b$ (Take the partial derivative of the cost function with respect to Weights and bias $dw$ and $db$)
5. Update $w$ and $b$ ($w := w - \alpha dw$ and $b := b - \alpha db$)
6. Repeat from Step 2 with new values of $w$ and $b$ for 'n' number of iterations.

• $\alpha$ is the learning rate (hyperparameter) that controls how much we are adjusting the weights and bias of our model with respect to the loss gradient. It is a small positive value (e.g., 0.01, 0.001) that determines the step size at each iteration while moving toward a minimum of the loss function.

Gradient Descent Types​

• Batch Gradient Descent (BGD)
• Stochastic Gradient Descent (SGD)
• Mini-batch Gradient Descent (MBGD)

Batch Gradient Descent (BGD)​

1. Process each input sample and find the cost
2. Find the average cost oveer all input samples
3. Update $w$ and $b$ and repeat the steps for "n" epochs(iterations)

• Disadvantages:
  • It uses the complete dataset to calculate the gradients at every steps
  • Slow when training data is large
  • Difficult to find the learning rate
  • Difficult to ascertain the number of epochs(iterations)

Stochastic Gradient Descent (SGD)​

Due to the random nature, the algorithm is much less regular than BGD.

1. Process a random input sample and find the cost.
2. Update $w$ and $b$, and repeat the steps for "n" iterations on the training samples.

• Advantages:
  • Computes gradient based on single input sample, which is memory efficient.
  • Much faster compared to BGD.
  • Possible to train on large datasets.
  • Randomness is helpful to escape local minima.
• Disadvantages:
  • Might not reach the optimal value, but very close to it.
    • Simulated annealing: Reduce the learning rate gradually
    • Create a Learning Schedule to determine the learning rate at each iteration.

Mini-batch Gradient Descent (MBGD)​

1. Divide the tranining set into mini-batches of size $n$ (e.g., 64, 128, 256).
2. Process all the samples in a mini-batch and find the average cost
3. Update $w$ and $b$, and repeat the steps for "n" iterations/epoches on the traning samples.

• Advantages:
  • Computes gradient based on small sets of input smaple
  • Much faster compared to BGD.
  • Possible to train on large dataset.
  • Performance boost on matrix operations using GPUs.
  • Might not reach the optional value but, very close to it and possibly better than SGD.
• Disadvantages:
  • It may be harder to escape the local minima compared to SGD.

Exponentially Weighted Averages​

• One of the popular algorithm for smoothing sequential data (time series data), aka. moving average.
• Weight the number of observations and using their average

$V_t$ is approximate average over $\approx \frac{1}{1 - \beta}$ time steps.

• For $\beta = 0.9$, $V_t$ is average over the last 10 time steps.
• For $\beta = 0.98$, $V_t$ is average over the last 50 time steps.
• For $\beta = 0.5$, $V_t$ is average over the last 2 time steps.

Optimizers​

SGD with Moementum​

At iteration $t$:

• Calculate $dw$ and $db$ on the current mini-batch (Hyper parameters: $\alpha$ and $\beta$)
• Update the velocity:
  • $V_{dw} = \beta V_{dw} + (1 - \beta) dw \rightarrow V_t = \beta V_{t-1} + (1 - \beta) \theta_t$
  • $V_{db} = \beta V_{db} + (1 - \beta) db$
• Update parameters:
  • $w := w - \alpha V_{dw}$
  • $b := b - \alpha V_{db}$

RMSProp​

• Root Mean Square Propagation.
• Unpublished adaptive learning method by Geoffrey Hinton.
• Reduces oscillation but in a different way than Momentum.
• Divides the learning rate by an exponentially decaying average of squared gradients.
• Calculate $dw$ and $db$ on the current mini-batch
  • $S_{dw} = \beta S_{dw} + (1 - \beta) dw^2$
  • $S_{db} = \beta S_{db} + (1 - \beta) db^2$
• Update parameters:
  • $w := w - \alpha \frac{dw}{\sqrt{S_{dw}} + \epsilon}$
  • $b := b - \alpha \frac{db}{\sqrt{S_{db}} + \epsilon}$
  • $\epsilon$ is a small number to prevent division by zero (e.g., $10^{-8} \text{ to } 10^{-10}$)

Adam​

• Adaptive Moment Estimation
• Combination of RMSProp and Momentum
• Work well for a wide range of non-convex optimization problems in machine learning.
• Calculate $dw$ and $db$ on the current mini-batch
  • $V_{dw} = \beta_1 V_{dw} + (1 - \beta_1) dw \leftarrow Momentum, \beta_1$
  • $V_{db} = \beta_1 V_{db} + (1 - \beta_1) db$
  • $S_{dw} = \beta_2 S_{dw} + (1 - \beta_2) dw^2 \leftarrow RMSProp, \beta_2$
  • $S_{db} = \beta_2 S_{db} + (1 - \beta_2) db^2$
• Update parameters:
  • $w := w - \alpha \frac{V_{dw}}{\sqrt{S_{dw}} + \epsilon}$
  • $b := b - \alpha \frac{V_{db}}{\sqrt{S_{db}} + \epsilon}$
  • $\epsilon$ is a small number to prevent division by zero (e.g., $10^{-8} \text{ to } 10^{-10}$)
• Hyper parameter guide:
  • $\alpha = 0.001$
  • $\beta_1 = 0.9$: Momentum term
  • $\beta_2 = 0.999$: Moving weighted average
  • $\epsilon = 10^{-8}$: To prevent division by zero
• ensmallen.org

Learning Rate Decay​

• Speed-up the learning algorighm by slowing decreasing the learning rate $\alpha$ as the number of epochs increases.

Activation Functions​

• Getting the output of a layer in a neural network and applying a non-linear function to it.
  • Sigmoid: $\sigma(x) = \frac{1}{1 + e^{-x}}$
  • Tanh: $\tanh(x) = \frac{2}{1 + e^{-2x}} - 1$
  • Used for binary classification in the output layer.
• ReLU: $A(x) = \max(0, x)$
  • Rectified Linear Unit
  • Avoids and rectifies vanishing gradient problem
  • Best used in hidden layers
  • Computationally less expensive than sigmoid and tanh
• Softmax: $S(x_i) = \frac{e^{x_i}}{\sum_{j} e^{x_j}}$
  • Turns numbers in probabilities that sum to 1.
  • Used for multi-class classification in the output layer.

Encoding​

• Basis encoding: binary srings -> computational basis states
• Amplitude encoding: data values -> amplitudes of a quantum state
• Angle encoding: data values -> rotation angles on individual qubits

Basis Encoding​

$x = b_1 b_2 ... b_n \rightarrow \ket{x} = \ket{b_1 b_2 ... b_n}$

• applying $X$ gates to flip qubits from $\ket{0}$ to $\ket{1}$ based on the binary representation of the data.
• $\ket{00} \rightarrow \ket{01}$ (X gate on the second qubit)
• $\ket{00} \rightarrow \ket{10}$ (X gate on the first qubit)
• Dataset superposition: to encode set $\{01, 11\}$
  • $\ket{S} = \frac{1}{\sqrt{2}}(\ket{01} + \ket{11})$
  • it requires Hadamard and/or controlled gates
• Hadamard transform
  • $\ket{H^{\otimes n}}\ket{0}^{\otimes n} = \frac{1}{\sqrt{2^n}} \sum_{x=0}^{2^n-1} \ket{x}$

import pennylane as qml

x = [int(b) for b in '1011']

def circuit(x):
  qml.BasisEmbedding(features=x, wires=range(len(x)))

dev = qml.device('default.qubit', wires=4)
qnode = qml.QNode(circuit, dev)

print(qml.draw(qml.transforms.decompose(qnode), show_all_wires=True)(x))

Amplitude Encoding​

$x = [x_0, x_1, ..., x_{N-1}] \rightarrow |\psi\rangle = \sum_{i=0}^{2^N-1} x_k |k\rangle$

• The most qubit-efficient encoding method, since $n$ qubits can encode $2^n$ amplitudes.

• The state can be rewritten more explicitly (for 3 qubits)

$\ket{\psi} = x_0 \ket{000} + x_1 \ket{001} + x_2 \ket{010} + x_3 \ket{011} + x_4 \ket{100} + x_5 \ket{101} + x_6 \ket{110} + x_7 \ket{111}$

• For $N$ data points, we need $n = \log_2(N)$ qubits.
• Converting to binary
  • with $n$ qubits, the computational basis states range from
    • $\ket{0}$ to $\ket{2^n - 1}$
  • $[x_0, x_1, ..., x_{N-1}]$ can be mapped to $x_0\ket{000} + x_1\ket{001} + \cdots + x_{N-1}\ket{(N-1)}$.
  • $b_i = \left\lfloor \frac{k}{2^i} \right\rfloor \bmod 2$.
• if $k = 5$
  • $b_0 = \left\lfloor \frac{5}{2^0} \right\rfloor \bmod 2 = 1$
  • $b_1 = \left\lfloor \frac{5}{2^1} \right\rfloor \bmod 2 = 0$
  • $b_2 = \left\lfloor \frac{5}{2^2} \right\rfloor \bmod 2 = 1$
  • gives $b_2 b_1 b_0 = 101$ (binary representation of 5)
  • $\ket{\bf 5} = \ket{101}$

Angle Encoding​

• Each classical value controls the roation angle of a qubit gate.
• $x = [x_1, x_2, ..., x_n]$
• $RY(x_0) \ket{0} \otimes RY(x_1) \ket{0} \otimes ... \otimes RY(x_{n-1}) \ket{0}$
• where $RY(\theta) = \begin{bmatrix} \cos(\theta/2) & -\sin(\theta/2) \\ \sin(\theta/2) & \cos(\theta/2) \end{bmatrix}$ is the $Y$ rotation gate.

Summary of Encoding Methods​

• Pennylane: BasisEmbedding, AmplitudeEmbedding, AngleEmbedding
• Qiskit: initialize
• PyTKET: StatePreparationBox

Amplitude Encoding Circuit​

• The algorithm to prepare an arbitrary vector of length $2^n$ takes roughly that many gates. (e.g. $2^3 \approx 10$)

wires = [0, 1, 2]

def circuit(x):
  qml.AmplitudeEmbedding(x, wires)

dev = qml.device("default.qubit", wires=wires)
qnode = qml.QNode(circuit, dev)

# Random vector of length 8 (for 3 qubits)
x = np.random.rand(8)
# Normalize the vector to have unit length (required for quantum states)
x = x/np.sqrt(np.sum(x**2))

qml.draw_mpl(qnode)(x);
qml.draw_mpl(qml.transforms.decompose(qnode), decimals=3)(x);

from pytket.circuit import StatePreparationBox
from pytket.circuit.display import render_circuit_jupyter as draw

state_circ = pytket.circuit.Circuit(3)

# Example 3-qubit state to prepare
w_state = 1 / np.sqrt(3) * np.array([0, 1, 1, 0, 1, 0, 0, 0])

w_state_box = StatePreparationBox(w_state)
state_circ.add_gate(w_state_box, [0, 1, 2])

draw(state_circ)

pytket.transform.Transform.DecomposeBoxes().apply(state_circ)
draw(state_circ)

Different algorithms for Rotation gate​

• Pennylane: Transformation of quantum states using uniformly controlled rotations $Ry(\theta) = e^{-\theta Y / 2} = \begin{bmatrix} \cos(\theta/2) & -\sin(\theta/2) \\ \sin(\theta/2) & \cos(\theta/2) \end{bmatrix}$

• PyTKET: Synthesis of Quantum Logic Circuits $R_y(\theta) = e^{-\theta \pi Y / 2} = \begin{bmatrix} \cos(\theta \pi / 2) & -\sin(\theta \pi / 2) \\ \sin(\theta \pi / 2) & \cos(\theta \pi / 2) \end{bmatrix}$

• Qiskit: Quantum Circuits for Isometries

• There are concreate algorithms for encoding classical data into quantum states, but this process is generally computationally expensive.

• It usually requires classical preprocessing, and the resulting circuit can be quite deep.

• In general, amplitude encoding an arbitary large vector is expensive.

• "a quantum computer can store an exponential amount of data" should be always considered together with the cost of state preparation.

• The real advantage of quantum computers does not appear for every problem, but only for specific problems that are well-suited to them.

  • Problems where state preparation is natural or efficient.
  • Problems that involve simulating quantum systems themselves.
  • Structured linear algebra, optimization, or sampling problems.
  • Problems where the input is already given as a quantum state.

Binary Logic Gates​

• Sum $s = a \oplus b$ (XOR)
• Carry $c = a \cdot b$ (AND)

1. Declare registers
2. Apply opertions
3. Read the result

Full-Adder in Binary Logic​

• Handles three inpus ($a$, $b$, and carry-in $c_{in}$) and produces two outputs (sum $s$ and carry-out $c_{out}$).

• $s = a \oplus b \oplus c_{in}$
• $c_{out} = (a \cdot b) \oplus (a \cdot c_{in}) \oplus (b \cdot c_{in})$
• A full-adder = two half-adders + an OR gate
• Chaning full-adders producs a ripple-carry adder for multi-bit numbers.

Quantum Arithmetic​

• All quantum gates must be Unitary (Invertable)
• A classical half-adder discards input information after computing the sum and carry.
  • This irreversibility is forbidden in quantum circuits.
• The computation must be done in a way that preserves all input information.
  • XOR and AND operations must be implemented using reversible gates (e.g. Toffoli gate).
  • XOR $\rightarrow$ CNOT gate
  • AND $\rightarrow$ Toffoli gate

• With a third qubit initialized to $\ket{0}$, we can compute the AND of $a$ and $b$ without losing information about $a$ and $b$.

Half-Adder​

Full-Adder​

$C_{out} = (a \cdot b) \oplus (a \cdot c_{in}) \oplus (b \cdot c_{in})$ $s = a \oplus b \oplus c_{in}$

$CCX(a, b, c_{out}) \rightarrow CNOT(a, b) \rightarrow CCX(b, c_{in}, c_{out}) \rightarrow CNOT(b, c_{in})$

Ripple Carry Adder​

• Two full-adder circuits in sequence, overlapping on the carry qubit ("rippling" the carry through the circuit).
• CDKM adder
  • Carry-out is the majority vote of the three inputs

• MAJ: Majority, computes carry in-place using only 2 CNOTs + 1 Toffoli

  • $(c, b, a) \rightarrow (c \oplus a, b \oplus a, a \cdot b \oplus a \cdot c \oplus b \cdot c)$

• UMA: UnMajority-and-Add, reverses MAJ but overwrites $b$ with the sum.

  • $c \oplus a, b \oplus a, c_{out} \rightarrow c, a\oplus b\oplus c, s$

• CDKM Ripple-Carry Adder: For two n-bit numbers, chain MAJ/UMA pairs, sharing the carry qubit.
  • CDKMRippleCarryAdder

Quantum Multiplication​

• Binary multiplication is "shift and add"
  • for each 1-bit in the multiplier, add a shifted version of the multiplicand to the result.
  • for each 0-bit, add nothing (or add a zero vector).
• In quantum, each partial addition is a conditional adder , every internal gate is controlled by a bit of the multiplier.

$CU = \ket{0}\bra{0} \otimes I + \ket{1}\bra{1} \otimes U$

Superposition​

• Same adder circuit works on superposition of inputs

$\text{ADDER} \ket{2} (\ket{1} + \ket{3}) \ket{0} = \ket{2} (\ket{1} \ket{3})(\ket{3} \ket{5})$

• With one adder, both $2 + 1$ and $2 + 3$ are computed simultaneously.
• measurement collapses the superposition, we can only ever see one result per run. Either $2 + 1 = 3$ or $2 + 3 = 5$.
• Amplifying the probability of amplitudes corresponding to correct answers is a key part of quantum algorithms.

Summary​

• Basis encoding maps each classical bit to a qubit, with 0 mapped to $|0\rangle$ and 1 mapped to $|1\rangle$.
• To encode 1011, we need X gates on qubits 0, 2, and 3 (assuming qubit 0 is the most significant bit).
• Applying an H gate (Hadamard gate) to each qubit puts the system in a uniform superposition over all basis states.
• Amplitude encoding of an arbitrary vector of size $2^n$ generally requires $O(2^n)$ gates.
• In angle encoding, each classical value $x_i$ becomes the rotation angle of an RY gate on the $i$-th qubit.
• Using the binary conversion formula, the decimal number 5 maps to $|101\rangle$ for 3 qubits.
• In short, in quantum addition, the sum is an XOR operation, and the carry is an AND operation.
• A quantum half-adder must keep the original inputs to remain reversible and maintain its unitary nature.
• The Toffoli gate is defined as: $|a\rangle|b\rangle|c\rangle \mapsto |a\rangle|b\rangle|c \oplus a \cdot b\rangle$.
• A full-adder should produce a carry-out as follows: $c_{\text{out}} = a \cdot b \oplus a \cdot c_{\text{in}} \oplus b \cdot c_{\text{in}}$.
• The following operation is reversible: $|a\rangle|b\rangle|c\rangle \mapsto |a\rangle|a \oplus b\rangle|c \oplus a \cdot b\rangle$.
• For addition "in superposition," measuring the output register yields exactly one of the partial sums, chosen probabilistically.
• The MAJ circuit computes the majority function as: $a \cdot b \oplus a \cdot c \oplus b \cdot c$.
• The QASM snippet for a half-adder uses ccx q[0], q[1], q[2] to compute the carry ($a \cdot b$) and a cx q[0], q[1] (or cx q[1], q[0]) gate to compute the sum ($a \oplus b$).
• Quantum multiplication can be implemented via conditional addition, one per multiplier bit.

Superdense Coding​

• counterintuitive protocol that allows us to send 2 bits of classical information by sending only 1 qubit, using pre-shared entanglement
• it's often contextualized as a game with Alice and Bob.
• Alice and Bob share and entangled pair of qubits
• Pre-shared Entanglement (Shared Bell pair)
  • $|\Phi^+\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle)$
• Alice wants to send 2 bits of classical information (00, 01, 10, or 11) to Bob
  • For 00: Apply Identity $I$ (do nothing)
  • For 01: Apply Pauli-X $X$ (bit flip)
  • For 10: Apply Pauli-Z $Z$ (phase flip)
  • For 11: Apply $XZ$ (bit and phase flip)
• Alice sends her one qubit to Bob (Bob possesses both qubits of the entangled pair)
• Bob decodes the information
  • Inverts the entanglement operation on the two qubits (CNOT followed by Hadamard)
  • Measures each of the qubits
  • The outcome of this measurement reveals the two bits Alice encoded.
• $|\Phi^+\rangle$: is the most common and convenient form (Bell State) of entanglement and is also maximally entangled state despite single-qubit unitary gates.
  • Easy to build circuits for it
  • Symmetric and has nice properties that make it ideal for protocols like superdense coding and teleportation
  • Other Bell states can be generated from $|\Phi^+\rangle$ by applying single-qubit gates.

Superdense Coding Circuit​

• Alice's message $mn$, where each of $m$ and $n$ is a bit (0 or 1)
• Alice's operation can be represented as $Z^m X^n \otimes \mathbb{I} | \Phi^+\rangle$
  • $m=0 \Rightarrow Z^0 = I$ (no phase flip)
  • $m=1 \Rightarrow Z^1 = Z$ (phase flip)
  • $n=0 \Rightarrow X^0 = I$ (no bit flip
  • $n=1 \Rightarrow X^1 = X$ (bit flip)
  • $00 \rightarrow I$
  • $01 \rightarrow X$
  • $10 \rightarrow Z$
  • $11 \rightarrow ZX$
• $Z^m|b\rangle = (-1)^{mb}|b\rangle$ (phase flip)
• $X^n|a\rangle = |a \oplus n\rangle$ (xor operation)

$X^n \left(\frac{1}{\sqrt{2}} (|00\rangle + |11\rangle)\right) = \frac{1}{\sqrt{2}} \left( |n0\rangle + |(1\oplus n)1\rangle \right)$

• $n=0$: $\frac{1}{\sqrt{2}} (|00\rangle + |11\rangle) = |\Phi^+\rangle$
• $n=1$: $\frac{1}{\sqrt{2}} (|10\rangle + |01\rangle)$

$Z^m X^n \left(\frac{1}{\sqrt{2}} (|00\rangle + |11\rangle)\right) = \frac{1}{\sqrt{2}} \left( (-1)^{mn}|n0\rangle + (-1)^{m(1\oplus n)}|(1\oplus n)1\rangle \right)$

• $|n0\rangle$: first qubit is $n$, $(-1)^{mn}$ is the phase factor
• $|(1\oplus n)1\rangle$: first qubit is $1\oplus n$, $(-1)^{m(1\oplus n)}$ is the phase factor
• Bob's decoding operation is the inverse of the entanglement operation
  • $CNOT |a\rangle |b\rangle = |a\rangle |a \oplus b\rangle$

• which is seperable state.
• First qubit is $|n\rangle + (-1)^m|1 \oplus n\rangle$ and second qubit is $|n\rangle$.
• $n, m \in \{0, 1\}$, then apply Hadamard to the first qubit:

• second qubit is $|n\rangle$, so the final state is:

$(-1)^{mn}(-1)^{nm}|m\rangle|n\rangle = |mn\rangle$

Superdense QASM​

OPENQASM 2.0;
qreg q[2];
creg c[2];

// Prepare Bell pair
h q[0];
cx q[0],q[1];

// Alice's encoding
// For message 11: apply X and Z
x q[0];
z q[0];

// Alice sends q[0] to Bob (in simulation, we just proceed)

// Bob's decoding
cx q[0],q[1];
h q[0];

// Measure both qubits
measure q[0] -> c[0];
measure q[1] -> c[1];

QASM Programming​

Custom Gates​

// params: parameters for the gate (e.g., rotation angles)
// q_args: quantum arguments (qubits the gate acts on)
gate NAME(parameters) q_args {
  // Define gate operations
}

gate bell a,b {
  h a;
  cx a,b;
}

qreg q[2];
creg c[2];

// Use the custom bell gate
bell q[0], q[1];

// Measure the qubits
measure q[0] -> c[0];
measure q[1] -> c[1];

Toffoli Gate​

// Toffoli gate (CCX)
gate ccx a, b, c {
  h c;
  cx b, c;
  tdg c;
  cx a, c;
  t c;
  cx b, c;
  tdg c;
  cx a, c;
  t b;
  t c;
  cx a, b;
  h c;
  t a;
  tdg b;
  cx a, b;
}

Rotation Gates​

// Rotation around Y-axis
gate ry_deg(theta) q {
  ry(theta/180 * pi) q;
}

// Rotation around X-axis
gate rx_deg(theta) q {
  rx(theta/180 * pi) q;
}

Qiskit​

IBM

import qiskit

superdense = qiskit.QuantumCircuit(2, 2)
superdense.draw()

superdense.h(0)
superdense.cx(0, 1)
superdense.draw()

# Alice's encoding for message '11'
superdense.x(0)
superdense.z(0)
superdense.draw()

# Bob unentangles the two qubits (reverses the entangling gate)
superdense.cx(0,1)
superdense.h(0)

# The measurement pattern is `measure(qubit to measure, classical bit to store result)`
superdense.measure(0,0)
superdense.measure(1,1)
superdense.draw()

from qiskit.providers.basic_provider import BasicSimulator

sim = BasicSimulator()
# run the circuit on the simulator with 1 shot (execute the circuit once)
result = sim.run(superdense, shots=1).result().get_counts()

print(result)
# {'11': 1}

Custom Gates in Qiskit​

bell = qiskit.QuantumCircuit(2, name='bell')
bell.h(0)
bell.cx(0, 1)
bell_gate = bell.to_gate()

c = qiskit.QuantumCircuit(2)
c.append(bell_gate, [0, 1])
c.draw()

Decompose a custom gate​

ccxgate = qiskit.circuit.library.CCXGate()
ccx = qiskit.QuantumCircuit(3)
ccx.append(ccxgate, [0, 1, 2])

print(ccx)
print(ccx.decompose())

Cirq​

Google

import cirq

alice = cirq.NamedQubit('Alice')
bob = cirq.NamedQubit('Bob')

superdense = cirq.Circuit()
superdense.append([
  cirq.H(alice),
  cirq.CNOT(alice, bob),
])

superdense.append([
  cirq.X(alice),
  cirq.Z(alice),
])

superdense.append([
  cirq.CNOT(alice, bob),
  cirq.H(alice),
])

superdense.append(cirq.measure(alice, bob, key='received'))

print(superdense)

simulator = cirq.Simulator()
result = simulator.run(superdense, repetitions=1)
print(result)
# received=1, 1

Pennylane​

Xanadu

import pennylane as qml

def entangle():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])

print(qml.draw(entangle)())

device = qml.device("default.qubit", wires=[0, 1])

# Wrap the quantum function as a QNode
entangle_qnode = qml.QNode(my_circuit, device)

# Set the number of shots to 10
entangle_qnode = qml.set_shots(entangle_qnode, shots=10)

import numpy as np

state = np.array([1, 1j], dtype=complex)

state = state / np.linalg.norm(state)

def teleport(state):
    # Ensure "state" is loaded into the first qubit
    # (otherwise qubits would start in |0>)
    qml.StatePrep(state, wires=0)

    # Shared entanglement between qubits 1 and 2
    qml.Hadamard(wires=1)
    qml.CNOT(wires=[1, 2])

    # Alice's operation:
    # CNOT from Alice's input qubit to her half of the Bell pair,
    # then Hadamard on the input qubit
    qml.CNOT(wires=[0, 1])
    qml.Hadamard(wires=0)

    # Measurement (store the classical outcomes)
    m0 = qml.measure(0)
    m1 = qml.measure(1)

    # Bob's conditional correction operations
    qml.cond(m1, qml.PauliX)(wires=2)
    qml.cond(m0, qml.PauliZ)(wires=2)

    # Return Bob's qubit as a density matrix
    return qml.density_matrix(wires=2)

print(qml.draw(teleport)(state))

Quantum Teleportation​

• if there is entanglement:
  • we can use it to send 2 bits of classical information by sending 1 qubit (superdense coding)
  • we can use it to send 1 qubit of quantum information by sending 2 bits of classical information (teleportation)
• Alice wants to send a qubit $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$ to Bob, but only has a classical channel.

Protocol​

1. Alice and Bob share $|\Phi^+\rangle$ (pre-shared entanglement)
2. Alice applies $CNOT$ (her qubit -> her Bell half), then $H$, then measures both, obtaining 2 classical bits (00, 01, 10, or 11)
3. Alice sends $mn$ classically to Bob
4. Bob applies $X^n Z^m$ to his qubit, recovering $|\psi\rangle$

• For 00: Apply Identity $I$ (do nothing)
• For 01: Apply Pauli-X $X$ (bit flip)
• For 10: Apply Pauli-Z $Z$ (phase flip)
• For 11: Apply $XZ$ (bit and phase flip)
• Bob now has a qubit in the state Alice wanted to send $|\psi\rangle$ without Alice ever sending a qubit directly to Bob.

Teleportation Circuit​

$|\psi\rangle \otimes |\Phi^+\rangle = \left(\alpha |0\rangle + \beta |1\rangle\right) \otimes \frac{1}{\sqrt{2}} \left(|00\rangle + |11\rangle\right)$

$|\psi\rangle \otimes |\Phi^+\rangle = \frac{1}{\sqrt{2}} \left(\alpha |0\rangle |00\rangle + \alpha |0\rangle |11\rangle + \beta |1\rangle |00\rangle + \beta |1\rangle |11\rangle\right)$

• Alice applies a $CNOT$ gate with her qubit $|\psi\rangle$ as control and her half of the Bell pair $|\Phi^+\rangle$ as target.
  • $\beta |1\rangle |00\rangle$ becomes $\beta |1\rangle |10\rangle$ (target flips when control is 1)
  • $\beta |1\rangle |11\rangle$ becomes $\beta |1\rangle |01\rangle$ (target flips when control is 1)

$\frac{1}{\sqrt{2}} \Big(\alpha |0\rangle |00\rangle + \alpha |0\rangle |11\rangle + \beta |1\rangle |10\rangle + \beta |1\rangle |01\rangle\Big)$

• Alice then applies a Hadamard gate to her qubit ($|\psi\rangle$).
  • $H|0\rangle = \frac{|0\rangle + |1\rangle}{\sqrt{2}}$
  • $H|1\rangle = \frac{|0\rangle - |1\rangle}{\sqrt{2}}$
• To prepare for measurement, Bell measurement is performed on Alice's two qubits, which can be expressed as:

• Alice measures her two qubits, resulting in one of four possible outcomes corresponding to the classical bits $|mn\rangle$ where $m, n \in \{0, 1\}$
  • Alice's two qubits: $|00\rangle, |0 1\rangle, |1 0\rangle, |1 1\rangle$
  • Bob's qubit is in a state that depends on Alice's measurement outcome

$X^n Z^m |\psi\rangle$

Channels​

• Classical Channel: carries bits (fibre, radio, paper, ...)
• Quantum Channel: carries qubits (can also carry bits)
  • Quantum channels can emulate classical ones, but not vice versa
• Teleportation: classical channel + pre-shared entanglement -> effective quantum channel

Summary​

• In superdense coding, by sending only one qubit and using pre-shared entanglement, Alice can transmit two classical bits of information.
• The operation $X^n \lvert a \rangle = \lvert a \oplus (n \bmod 2) \rangle$ correctly defines the effect of applying the $X$ gate $n$ times.
• The tensor product of two identity operators is the identity operator on the composite space. In symbols, where the subscript is the dimension: $I_2 \otimes I_2 = I_4$.
• The state $\lvert \phi \rangle = \frac{1}{\sqrt{2}}(\lvert 0 \rangle + \lvert 1 \rangle)$ is an eigenstate of the Pauli-$X$ gate with eigenvalue $+1$.
• In the teleportation protocol, the classical communication channel is used to transmit two classical bits from Alice to Bob.
• Three qubits are required for quantum teleportation.
• After the teleportation protocol completes, Bob has a qubit in the state $\lvert \psi \rangle$.
• Of QASM, Qiskit, Cirq, and PennyLane, PennyLane is the only quantum language that spells out the full name of the Hadamard gate for its built-in gates.