added codes

Author: mhjensen

doc/Programs/QFTcodes/Qftcode.txt

@@ -0,0 +1,94 @@
+Certainly! Below is a full Python implementation that:
+
+Implements the Quantum Fourier Transform (QFT) for an arbitrary number of qubits using only numpy.
+Implements the classical Fast Fourier Transform (FFT) using numpy.fft.fft.
+Compares the result of the QFT (on computational basis states) with the FFT to demonstrate their correspondence.
+
+
+
+
+
+🧠 
+Key Insight
+
+
+The QFT maps quantum basis states |x\rangle to quantum Fourier states using:
+|x\rangle \mapsto \frac{1}{\sqrt{2^n}} \sum_{k=0}^{2^n - 1} e^{2\pi i xk / 2^n} |k\rangle
+This is essentially the Discrete Fourier Transform (DFT) up to global phases and bit-reversals.
+
+
+
+
+✅ Python Code
+
+import numpy as np
+
+def qft_matrix(n):
+    """Construct the Quantum Fourier Transform matrix for n qubits."""
+    N = 2 ** n
+    omega = np.exp(2j * np.pi / N)
+    qft = np.zeros((N, N), dtype=complex)
+    for i in range(N):
+        for j in range(N):
+            qft[i, j] = omega ** (i * j)
+    return qft / np.sqrt(N)
+
+def apply_qft(state_vector):
+    """Apply QFT to a given state vector using matrix multiplication."""
+    N = len(state_vector)
+    n = int(np.log2(N))
+    if 2**n != N:
+        raise ValueError("Length of state vector must be a power of 2.")
+    QFT = qft_matrix(n)
+    return QFT @ state_vector
+
+def compare_qft_fft(n, basis_index=0):
+    """Compare QFT and FFT on a computational basis state |basis_index>."""
+    N = 2 ** n
+    # Initialize the computational basis state |basis_index>
+    state = np.zeros(N, dtype=complex)
+    state[basis_index] = 1.0
+
+    # Apply QFT
+    qft_result = apply_qft(state)
+
+    # Classical FFT (with normalization)
+    fft_result = np.fft.fft(state) / np.sqrt(N)
+
+    # Compare magnitudes and phases
+    print(f"\nComparing QFT and FFT results for |{basis_index}> with {n} qubits:")
+    for i in range(N):
+        print(f"Index {i:2d}: QFT = {qft_result[i]:.4f}, FFT = {fft_result[i]:.4f}, "
+              f"Difference = {abs(qft_result[i] - fft_result[i]):.2e}")
+
+    return qft_result, fft_result
+
+# Example usage
+if __name__ == "__main__":
+    n_qubits = 3  # try with 2, 3, 4, etc.
+    for basis_idx in range(2 ** n_qubits):
+        compare_qft_fft(n_qubits, basis_idx)
+
+
+
+
+📊 What This Code Does
+
+
+Builds the QFT matrix explicitly for n qubits.
+Applies it to a computational basis state |x\rangle.
+Computes the FFT of the same state using NumPy.
+Compares QFT and FFT outputs element-wise for magnitude and phase.
+
+
+
+
+
+📝 Notes
+
+
+The QFT and FFT results match up to bit reversal and global phases, which do not affect measurement outcomes in quantum circuits.
+You can experiment by changing n_qubits and basis_idx in the if __name__ == "__main__" block.
+
+
+Would you also like a recursive gate-based implementation of the QFT (as in a real quantum circuit)?

doc/Programs/QFTcodes/testqft.py

@@ -0,0 +1,47 @@
+import numpy as np
+
+def qft_matrix(n):
+    """Construct the Quantum Fourier Transform matrix for n qubits."""
+    N = 2 ** n
+    omega = np.exp(2j * np.pi / N)
+    qft = np.zeros((N, N), dtype=complex)
+    for i in range(N):
+        for j in range(N):
+            qft[i, j] = omega ** (i * j)
+    return qft / np.sqrt(N)
+
+def apply_qft(state_vector):
+    """Apply QFT to a given state vector using matrix multiplication."""
+    N = len(state_vector)
+    n = int(np.log2(N))
+    if 2**n != N:
+        raise ValueError("Length of state vector must be a power of 2.")
+    QFT = qft_matrix(n)
+    return QFT @ state_vector
+
+def compare_qft_fft(n, basis_index=0):
+    """Compare QFT and FFT on a computational basis state |basis_index>."""
+    N = 2 ** n
+    # Initialize the computational basis state |basis_index>
+    state = np.zeros(N, dtype=complex)
+    state[basis_index] = 1.0
+
+    # Apply QFT
+    qft_result = apply_qft(state)
+
+    # Classical FFT (with normalization)
+    fft_result = np.fft.fft(state) / np.sqrt(N)
+
+    # Compare magnitudes and phases
+    print(f"\nComparing QFT and FFT results for |{basis_index}> with {n} qubits:")
+    for i in range(N):
+        print(f"Index {i:2d}: QFT = {qft_result[i]:.4f}, FFT = {fft_result[i]:.4f}, "
+              f"Difference = {abs(qft_result[i] - fft_result[i]):.2e}")
+
+    return qft_result, fft_result
+
+# Example usage
+if __name__ == "__main__":
+    n_qubits = 3  # try with 2, 3, 4, etc.
+    for basis_idx in range(2 ** n_qubits):
+        compare_qft_fft(n_qubits, basis_idx)