Update quread/gates.py

quread/gates.py

@@ -1,26 +1,90 @@
+# quread/gates.py
 import numpy as np
 
-# Single-qubit gates (2x2)
-I = np.eye(2, dtype=complex)
+I2 = np.eye(2, dtype=complex)
+
+H = (1 / np.sqrt(2)) * np.array([[1, 1], [1, -1]], dtype=complex)
 X = np.array([[0, 1], [1, 0]], dtype=complex)
 Y = np.array([[0, -1j], [1j, 0]], dtype=complex)
 Z = np.array([[1, 0], [0, -1]], dtype=complex)
-H = (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]], dtype=complex)
+
 S = np.array([[1, 0], [0, 1j]], dtype=complex)
-T = np.array([[1, 0], [0, np.exp(1j*np.pi/4)]], dtype=complex)
+Sdg = np.array([[1, 0], [0, -1j]], dtype=complex)
+
+T = np.array([[1, 0], [0, np.exp(1j * np.pi / 4)]], dtype=complex)
+Tdg = np.array([[1, 0], [0, np.exp(-1j * np.pi / 4)]], dtype=complex)
+
+# √X (standard definition)
+SQRTX = 0.5 * np.array([[1 + 1j, 1 - 1j],
+                        [1 - 1j, 1 + 1j]], dtype=complex)
+
+# √Z (principal square root): diag(1, e^{iπ/2}) = diag(1, i) == S
+SQRTZ = S
+
+
+def RX(theta: float) -> np.ndarray:
+    c = np.cos(theta / 2)
+    s = np.sin(theta / 2)
+    return np.array([[c, -1j * s],
+                     [-1j * s, c]], dtype=complex)
+
+
+def RY(theta: float) -> np.ndarray:
+    c = np.cos(theta / 2)
+    s = np.sin(theta / 2)
+    return np.array([[c, -s],
+                     [s, c]], dtype=complex)
+
+
+def RZ(theta: float) -> np.ndarray:
+    return np.array([[np.exp(-1j * theta / 2), 0],
+                     [0, np.exp(1j * theta / 2)]], dtype=complex)
+
 
-def rz(theta: float) -> np.ndarray:
-    return np.array([[np.exp(-1j*theta/2), 0],
-                     [0, np.exp(1j*theta/2)]], dtype=complex)
+def single_qubit_gate_matrix(gate: str) -> np.ndarray:
+    """
+    Supported gate strings:
+    H, X, Y, Z, S, Sdg, T, Tdg, SQRTX, SQRTZ,
+    RX_PI, RX_PI_2, RY_PI, RY_PI_2, RZ_PI, RZ_PI_2,
+    I
+    """
+    g = gate.strip()
 
-def ry(theta: float) -> np.ndarray:
-    return np.array([[np.cos(theta/2), -np.sin(theta/2)],
-                     [np.sin(theta/2),  np.cos(theta/2)]], dtype=complex)
+    if g == "I":
+        return I2
+    if g == "H":
+        return H
+    if g == "X":
+        return X
+    if g == "Y":
+        return Y
+    if g == "Z":
+        return Z
+    if g == "S":
+        return S
+    if g in ("S†", "Sdg"):
+        return Sdg
+    if g == "T":
+        return T
+    if g in ("T†", "Tdg"):
+        return Tdg
+    if g in ("√X", "SQRTX"):
+        return SQRTX
+    if g in ("√Z", "SQRTZ"):
+        return SQRTZ
 
-def rx(theta: float) -> np.ndarray:
-    return np.array([[np.cos(theta/2), -1j*np.sin(theta/2)],
-                     [-1j*np.sin(theta/2), np.cos(theta/2)]], dtype=complex)
+    # rotations (fixed angles from your palette)
+    if g == "RX(π)":
+        return RX(np.pi)
+    if g == "RX(π/2)":
+        return RX(np.pi / 2)
+    if g == "RY(π)":
+        return RY(np.pi)
+    if g == "RY(π/2)":
+        return RY(np.pi / 2)
+    if g == "RZ(π)":
+        return RZ(np.pi)
+    if g == "RZ(π/2)":
+        return RZ(np.pi / 2)
 
-SINGLE_QUBIT_GATES = {
-    "I": I, "X": X, "Y": Y, "Z": Z, "H": H, "S": S, "T": T
-}
+    raise ValueError(f"Unsupported gate: {gate}")