Update quread/engine.py

quread/engine.py

@@ -44,26 +44,78 @@ class QuantumStateVector:
     def apply_single(self, gate_name: str, target: int, theta: Optional[float] = None) -> None:
         if not (0 <= target < self.n_qubits):
             raise ValueError("target out of range")
+
+        def _parse_angle(label: str) -> float:
+            # supports: "π", "pi", "π/2", "pi/2"
+            s = label.strip().lower().replace(" ", "")
+            if s in ("π", "pi"):
+                return float(np.pi)
+            if s in ("π/2", "pi/2"):
+                return float(np.pi / 2)
+            raise ValueError(f"Unsupported angle in {gate_name}. Use π or π/2.")
+
+        g = gate_name.strip()
+    
+        # --- normalize common UI labels to internal canonical names ---
+        # dagger variants
+        if g in ("T†", "Tdg"):
+            g = "Tdg"
+        if g in ("S†", "Sdg"):
+            g = "Sdg"
+        # identity variants
+        if g in ("I†", "Idg"):
+            g = "I"
+        # sqrt variants
+        if g in ("√X", "SX"):
+            g = "SQRTX"
+        if g in ("√Z", "SZ"):
+            g = "SQRTZ"
+    
+        # --- build gate matrix ---
         gate = None
-        if gate_name in SINGLE_QUBIT_GATES:
-            gate = SINGLE_QUBIT_GATES[gate_name]
-        elif gate_name == "RX":
-            if theta is None: raise ValueError("RX requires theta")
+    
+        # fixed-angle rotation labels from UI
+        if g.startswith(("Rx(", "RX(")) and g.endswith(")"):
+            ang = _parse_angle(g[g.find("(")+1 : -1])
+            gate = rx(float(ang))
+            g = f"RX({g[g.find('(')+1:-1]})"  # preserve readable name in history
+    
+        elif g.startswith(("Ry(", "RY(")) and g.endswith(")"):
+            ang = _parse_angle(g[g.find("(")+1 : -1])
+            gate = ry(float(ang))
+            g = f"RY({g[g.find('(')+1:-1]})"
+    
+        elif g.startswith(("Rz(", "RZ(")) and g.endswith(")"):
+            ang = _parse_angle(g[g.find("(")+1 : -1])
+            gate = rz(float(ang))
+            g = f"RZ({g[g.find('(')+1:-1]})"
+    
+        # original parametric API still supported
+        elif g == "RX":
+            if theta is None:
+                raise ValueError("RX requires theta")
             gate = rx(float(theta))
-        elif gate_name == "RY":
-            if theta is None: raise ValueError("RY requires theta")
+    
+        elif g == "RY":
+            if theta is None:
+                raise ValueError("RY requires theta")
             gate = ry(float(theta))
-        elif gate_name == "RZ":
-            if theta is None: raise ValueError("RZ requires theta")
+    
+        elif g == "RZ":
+            if theta is None:
+                raise ValueError("RZ requires theta")
             gate = rz(float(theta))
+    
+        # all normal single-qubit gates (incl. new ones) via map
+        elif g in SINGLE_QUBIT_GATES:
+            gate = SINGLE_QUBIT_GATES[g]
+    
         else:
             raise ValueError(f"Unknown gate: {gate_name}")
-
+    
         # Apply using pairwise amplitude updates (no full 2^n x 2^n matrix)
-        # Convention: qubit 0 is the TOP wire in UI, but in basis indexing we treat
-        # qubit 0 as the most-significant bit (MSB). This keeps bitstrings readable.
-        msb_index = self.n_qubits - 1 - target  # convert "wire index" -> bit position from right
-
+        msb_index = self.n_qubits - 1 - target  # wire index -> bit position from right
+    
         new_state = self.state.copy()
         dim = len(self.state)
         for basis in range(dim):
@@ -71,13 +123,13 @@ class QuantumStateVector:
                 partner = _flip_bit(basis, msb_index)
                 a0 = self.state[basis]
                 a1 = self.state[partner]
-                # [a0'; a1'] = gate * [a0; a1]
-                new_state[basis]   = gate[0,0]*a0 + gate[0,1]*a1
-                new_state[partner] = gate[1,0]*a0 + gate[1,1]*a1
+                new_state[basis]   = gate[0, 0] * a0 + gate[0, 1] * a1
+                new_state[partner] = gate[1, 0] * a0 + gate[1, 1] * a1
+    
         self.state = _normalize_state(new_state)
-
-        op: Op = {"type": "single", "gate": gate_name, "target": target}
-        if theta is not None:
+    
+        op: Op = {"type": "single", "gate": g, "target": target}
+        if theta is not None and g in ("RX", "RY", "RZ"):
             op["theta"] = float(theta)
         self.history.append(op)