update

Author: mhjensen

doc/src/FuturePlans/book.pdf

@@ -1,33 +1,105 @@
-\documentclass[11pt]{book}
-\usepackage[utf8]{inputenc}
-\usepackage{amsmath, amssymb}
-\usepackage{physics}
+\documentclass[12pt]{book}
+\usepackage[a4paper,margin=1in]{geometry}
+\usepackage{amsmath,amsfonts,amssymb}
 \usepackage{graphicx}
 \usepackage{hyperref}
-\usepackage{xcolor}
+\usepackage{qcircuit}
 \usepackage{listings}
+\usepackage{xcolor}
 \usepackage{caption}
-\usepackage{geometry}
-\geometry{margin=1in}
-
-\title{Quantum Fourier Transform: Theory and Implementation}
-\author{}
-\date{}
+\usepackage{physics}
 
+\definecolor{codebg}{rgb}{0.95,0.95,0.95}
 \lstset{
- language=Python,
- basicstyle=\ttfamily\small,
- keywordstyle=\color{blue},
- commentstyle=\color{gray},
- stringstyle=\color{red},
- showstringspaces=false,
- breaklines=true,
- frame=single,
- captionpos=b
+  backgroundcolor=\color{codebg},
+  basicstyle=\ttfamily\footnotesize,
+  keywordstyle=\color{blue},
+  commentstyle=\color{gray},
+  stringstyle=\color{red},
+  breaklines=true,
+  postbreak=\mbox{\textcolor{red}{$\hookrightarrow$}\space},
+  frame=single,
+  showstringspaces=false
 }
 
+\title{Quantum Fourier Transform: Theory and Implementation}
+\author{Morten Hjorth-Jensen}
+\date{May 2021}
+
 \begin{document}
 
+\maketitle
+\tableofcontents
+
+\chapter{Introduction and Background}
+The Quantum Fourier Transform (QFT) is a central building block in quantum algorithms such as Shor's factoring algorithm and quantum phase estimation. It is the quantum analogue of the discrete Fourier transform (DFT) and enables efficient extraction of periodicity from quantum states.
+
+\section{Classical Fourier Transform}
+The classical Discrete Fourier Transform (DFT) on a vector $x = (x_0, ..., x_{N-1})$ is given by:
+\[
+\tilde{x}_k = \frac{1}{\sqrt{N}} \sum_{j=0}^{N-1} x_j e^{2\pi i jk / N}
+\]
+It is a unitary transformation and can be implemented in $O(N \log N)$ via the Fast Fourier Transform.
+
+\section{Quantum States and Qubits}
+A quantum register of $n$ qubits encodes a vector in $2^n$-dimensional Hilbert space:
+\[
+\ket{\psi} = \sum_{j=0}^{2^n - 1} x_j \ket{j}
+\]
+where $x_j$ are complex amplitudes satisfying $\sum |x_j|^2 = 1$.
+
+\section{Quantum Fourier Transform}
+The QFT on an $n$-qubit state transforms:
+\[
+\ket{j} \rightarrow \frac{1}{\sqrt{2^n}} \sum_{k=0}^{2^n - 1} e^{2\pi i jk / 2^n} \ket{k}
+\]
+This unitary matrix has exponential size, but can be implemented in $O(n^2)$ quantum gates.
+
+\section{Matrix Form}
+For $n = 2$ qubits, the QFT matrix is:
+\[
+\frac{1}{2}
+\begin{bmatrix}
+1 & 1 & 1 & 1 \\
+1 & i & -1 & -i \\
+1 & -1 & 1 & -1 \\
+1 & -i & -1 & i
+\end{bmatrix}
+\]
+
+\chapter{Circuit Implementation of QFT}
+
+\section{QFT Circuit Structure}
+The QFT is decomposed into Hadamard and controlled phase shift gates. For $n$ qubits, the standard structure is:
+
+\begin{enumerate}
+    \item Apply Hadamard to the most significant qubit.
+    \item Apply controlled-$R_k$ gates to encode phase shifts.
+    \item Repeat for remaining qubits.
+    \item Apply SWAP gates to reverse the order.
+\end{enumerate}
+
+\section{Quantum Gates Used}
+\begin{itemize}
+    \item \textbf{Hadamard gate:} $H = \frac{1}{\sqrt{2}} \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix}$
+    \item \textbf{Phase shift gate:} $R_k = \begin{bmatrix} 1 & 0 \\ 0 & e^{2\pi i / 2^k} \end{bmatrix}$
+\end{itemize}
+
+\section{QFT on 3 Qubits}
+Example for $n = 3$ qubits:
+\begin{enumerate}
+    \item Apply $H$ to qubit 0.
+    \item Apply $R_2$ (ctrl:1, tgt:0), $R_3$ (ctrl:2, tgt:0).
+    \item Repeat with Hadamard on qubit 1, $R_2$ from qubit 2.
+    \item Hadamard on qubit 2.
+    \item Apply SWAPs: swap(0,2).
+\end{enumerate}
+
+
+
+
+
+
 \maketitle
 
 \chapter{Mathematical Foundations and Motivation}
@@ -183,3 +255,262 @@ \section{Complexity}
 
 \section{Summary}
 The circuit implementation of QFT is surprisingly efficient, enabling its use in several key quantum algorithms. Understanding the gate-level construction deepens our understanding of quantum information flow during Fourier transformation.
+
+\chapter{Inverse QFT and Phase Estimation}
+
+\section{The Inverse QFT}
+The inverse Quantum Fourier Transform (IQFT) is simply the Hermitian adjoint of the QFT. Since the QFT is unitary, its inverse is:
+\[
+\text{QFT}^\dagger = \text{QFT}^{-1}
+\]
+
+\subsection*{Circuit Construction}
+To reverse the QFT circuit:
+\begin{enumerate}
+   \item Swap the order of gates.
+   \item Replace Hadamard gates with Hadamard gates (self-inverse).
+   \item Replace each $R_k$ gate with its conjugate transpose $R_k^\dagger$:
+   \[
+   R_k^\dagger = \begin{bmatrix}
+   1 & 0 \\
+   0 & e^{-2\pi i / 2^k}
+   \end{bmatrix}
+   \]
+\end{enumerate}
+
+\section{Quantum Phase Estimation (QPE)}
+Quantum Phase Estimation is a core quantum algorithm that uses the QFT to estimate the phase $\phi$ in:
+\[
+U \ket{u} = e^{2\pi i \phi} \ket{u}
+\]
+
+\subsection*{Algorithm Overview}
+Given an eigenvector $\ket{u}$ of a unitary $U$, the QPE algorithm estimates the phase $\phi$ using:
+
+\begin{enumerate}
+   \item Apply Hadamards to an $n$-qubit register.
+   \item Use controlled-$U^{2^k}$ gates to encode phase.
+   \item Apply inverse QFT to extract the binary digits of $\phi$.
+\end{enumerate}
+
+\section{Circuit Diagram (3-bit QPE)}
+The general circuit has:
+
+- Top register: $n$ qubits to encode phase.
+- Bottom register: one eigenstate $\ket{u}$.
+
+\[
+\Qcircuit @C=1em @R=1em {
+\lstick{\ket{0}} & \gate{H} & \ctrl{1} & \qw & \multigate{2}{\text{IQFT}} & \meter \\
+\lstick{\ket{0}} & \gate{H} & \ctrl{1} & \qw & \ghost{\text{IQFT}} & \meter \\
+\lstick{\ket{0}} & \gate{H} & \ctrl{1} & \qw & \ghost{\text{IQFT}} & \meter \\
+\lstick{\ket{u}} & {/} \qw & \gate{U^{2^k}} & \qw & \qw & \qw
+}
+\]
+
+\section{PennyLane Implementation of QPE}
+\begin{lstlisting}[language=Python]
+import pennylane as qml
+from pennylane import numpy as np
+
+n_estimation = 3
+dev = qml.device("default.qubit", wires=n_estimation + 1)
+
+def apply_controlled_unitaries(U, wires):
+   for i, ctrl in enumerate(wires[:-1]):
+       power = 2**i
+       for _ in range(power):
+           qml.ctrl(U, control=ctrl)(wires[-1])
+
+def inverse_qft(wires):
+   swap_registers(wires)
+   for i in reversed(range(len(wires))):
+       for j in range(i):
+           qml.ctrl(qml.PhaseShift, control=wires[j])(-np.pi / 2**(i - j), wires=wires[i])
+       qml.Hadamard(wires=wires[i])
+
+@qml.qnode(dev)
+def qpe():
+   target_wire = n_estimation
+   for i in range(n_estimation):
+       qml.Hadamard(wires=i)
+
+   qml.RZ(2 * np.pi * 0.375, wires=target_wire)  # Assume phase = 0.375
+
+   apply_controlled_unitaries(qml.RZ, list(range(n_estimation)) + [target_wire])
+   inverse_qft(list(range(n_estimation)))
+   return qml.probs(wires=range(n_estimation))
+
+probs = qpe()
+print("Measured phase state:", probs)
+\end{lstlisting}
+
+\section{Accuracy and Readout}
+The accuracy of phase estimation improves with the number of qubits in the control register. For $n$ qubits, we obtain the $n$ most significant bits of $\phi$.
+
+\section{Summary}
+The inverse QFT is essential for extracting phase information from quantum states. Combined with controlled unitary evolution, it enables phase estimation—a foundational subroutine for factoring, quantum simulations, and eigenvalue problems.
+
+ics, eigenvalues of unitary evolutions encode properties like energy levels. QPE, powered by QFT, is used to extract these values.
+
+\subsection*{Hamiltonian Simulation}
+Let $H$ be a Hamiltonian. The evolution $U = e^{-iHt}$ has eigenvectors $\ket{u}$ and eigenvalues $e^{-iEt}$. QPE yields estimates of $E$.
+
+\subsection*{Applications}
+- Electronic structure problems
+- Dynamics of molecules
+- Energy spectrum estimation
+
+\section{Amplitude Estimation}
+Quantum Amplitude Estimation (QAE) uses QFT for estimating probabilities (amplitudes) more efficiently than classical sampling.
+
+\subsection*{Basic Setup}
+Prepare a state:
+\[
+\ket{\psi} = \sqrt{a}\ket{1} + \sqrt{1 - a}\ket{0}
+\]
+QAE estimates $a$ using Grover-like iterations and QFT.
+
+\section{PennyLane Example: Energy Estimation}
+We simulate a simple diagonal Hamiltonian using QPE.
+
+\begin{lstlisting}[language=Python]
+  import pennylane as qml
+  from pennylane import numpy as np
+
+  n_qubits = 2
+  dev = qml.device(``default.qubit'', wires=n_qubits + 1)
+
+  def controlled_unitary(t):
+  def unitary():
+  qml.PhaseShift(2 * np.pi * 0.3 * t, wires=n_qubits)
+  return unitary
+
+  @qml.qnode(dev)
+  def energy_estimation():
+  # Apply Hadamards to estimation qubits
+  for i in range(n_qubits):
+  qml.Hadamard(wires=i)
+  # Prepare eigenstate for target qubit
+  qml.PauliX(wires=n_qubits)
+  # Apply controlled-U^{2^j}
+  for i in range(n_qubits):
+  unitary = controlled_unitary(2**i)
+  qml.ctrl(unitary, control=i)()
+  # Inverse QFT
+  inverse_qft(range(n_qubits))
+  return qml.probs(wires=range(n_qubits))
+
+  probs = energy_estimation()
+  print(``Measured energy phase:'', probs)
+\end{lstlisting}
+
+\section{Summary}
+The QFT enables exponential speedups in various quantum algorithms by exposing hidden periodicity, encoding eigenvalues, and amplifying amplitudes. Its applications span number theory, chemistry, and quantum finance, highlighting its centrality to quantum computing.
+
+
+large $k$ are highly sensitive to noise. Removing them improves fidelity on NISQ devices.
+
+\subsection*{Noise-Aware Compilation}
+Use device-specific compilers (e.g., Qiskit, tket) that minimize gate errors and optimize qubit layout.
+
+\section{Example: Approximate QFT in PennyLane}
+We modify our QFT to drop $R_k$ gates with angle $< \epsilon$:
+
+\begin{lstlisting}[language=Python]
+  def approximate_qft(wires, epsilon=1e-2):
+  if len(wires) == 0:
+  return
+  head, *tail = wires
+  qml.Hadamard(wires=head)
+  for i, qubit in enumerate(tail):
+  angle = np.pi / 2**(i+1)
+  if angle >= epsilon:
+  qml.ctrl(qml.PhaseShift, control=qubit)(angle, wires=head)
+  approximate_qft(tail)
+\end{lstlisting}
+
+This dramatically reduces depth for large $n$, making QFT feasible for hardware implementation.
+
+\section{Resource Summary}
+
+\begin{itemize}
+\item \textbf{Exact QFT}: $O(n^2)$ gates, accurate, but deep circuit.
+\item \textbf{Approximate QFT}: $O(n \log(1/\epsilon))$ gates, fast and NISQ-friendly.
+\item \textbf{Inverse QFT}: Similar structure, used in readout stages.
+\end{itemize}
+
+\section{Summary}
+Optimizing QFT for real-world execution is essential for practical quantum computing. Approximate QFTs maintain algorithmic utility while reducing quantum hardware demands. These optimizations are vital for algorithms targeting NISQ systems or requiring high repetition rates.
+
+sed(range(len(wires))):
+for j in range(i):
+qml.ctrl(qml.PhaseShift, control=wires[j])(-np.pi / 2**(i - j), wires=wires[i])
+qml.Hadamard(wires=wires[i])
+\end{lstlisting}
+
+\section{Code 3: Quantum Phase Estimation (QPE)}
+\begin{lstlisting}[language=Python]
+  n_estimation = 3
+  dev = qml.device(``default.qubit'', wires=n_estimation + 1)
+
+  def apply_controlled_unitaries(U, wires):
+  for i, ctrl in enumerate(wires[:-1]):
+  power = 2**i
+  for _ in range(power):
+  qml.ctrl(U, control=ctrl)(wires[-1])
+
+  @qml.qnode(dev)
+  def qpe():
+  target_wire = n_estimation
+  for i in range(n_estimation):
+  qml.Hadamard(wires=i)
+  qml.RZ(2 * np.pi * 0.375, wires=target_wire)
+  apply_controlled_unitaries(qml.RZ, list(range(n_estimation)) + [target_wire])
+  inverse_qft(list(range(n_estimation)))
+  return qml.probs(wires=range(n_estimation))
+
+  print(``Measured phase state:'', qpe())
+\end{lstlisting}
+
+\section{Code 4: Approximate QFT Implementation}
+\begin{lstlisting}[language=Python]
+  def approximate_qft(wires, epsilon=1e-2):
+  if len(wires) == 0:
+  return
+  head, *tail = wires
+  qml.Hadamard(wires=head)
+  for i, qubit in enumerate(tail):
+  angle = np.pi / 2**(i+1)
+  if angle >= epsilon:
+  qml.ctrl(qml.PhaseShift, control=qubit)(angle, wires=head)
+  approximate_qft(tail)
+\end{lstlisting}
+
+\section{Execution Tips}
+
+\begin{itemize}
+\item All examples can run on \texttt{default.qubit}, the standard PennyLane simulator.
+\item Use \texttt{qml.draw()} to visualize circuits.
+\item To run on real hardware (e.g., IBMQ, Xanadu X8), swap the device line with the appropriate plugin and set API keys.
+\item Use \texttt{qml.state()} or \texttt{qml.probs()} to inspect output.
+\item PennyLane supports backpropagation, enabling QFT-based circuits to be optimized or trained.
+\end{itemize}
+
+\section{Further Reading}
+
+\begin{itemize}
+\item PennyLane Documentation: \url{https://docs.pennylane.ai}
+\item Nielsen and Chuang, \emph{Quantum Computation and Quantum Information}
+\item Kitaev's Phase Estimation Algorithm (original source)
+\item Qiskit textbook: \url{https://qiskit.org/textbook}
+\end{itemize}
+
+\section{Summary}
+This appendix compiles all code needed to simulate and visualize QFT and its applications using PennyLane. With these examples, readers can replicate core quantum algorithms on simulators or real hardware with minimal changes.
+
+
+
+
+
+\end{document}