updated the cu gate to be like qiskit's

test/operators/test_op.py

@@ -48,6 +48,7 @@
     {"qiskit": qiskit_gate.CU1Gate, "tq": tq.CU1},
     # {'qiskit': qiskit_gate.?, 'tq': tq.CU2},
     {"qiskit": qiskit_gate.CU3Gate, "tq": tq.CU3},
+    {"qiskit": qiskit_gate.CUGate, "tq": tq.CU},
     {"qiskit": qiskit_gate.ECRGate, "tq": tq.ECR},
 ]
 

torchquantum/functional.py

@@ -58,6 +58,7 @@
     "cu1",
     "cu2",
     "cu3",
+    "cu",
     "qubitunitary",
     "qubitunitaryfast",
     "qubitunitarystrict",
@@ -959,6 +960,40 @@ def cu3_matrix(params):
 
     return matrix.squeeze(0)
 
+def cu_matrix(params):
+    """Compute unitary matrix for CU gate.
+
+    Args:
+        params (torch.Tensor): The rotation angle.
+
+    Returns:
+        torch.Tensor: The computed unitary matrix.
+
+    """
+    theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE)
+    phi = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE)
+    lam = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE)
+    gamma = params[:, 3].unsqueeze(dim=-1).type(C_DTYPE)
+
+    co = torch.cos(theta / 2)
+    si = torch.sin(theta / 2)
+
+    matrix = (
+        torch.tensor(
+            [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
+            dtype=C_DTYPE,
+            device=params.device,
+        )
+        .unsqueeze(0)
+        .repeat(phi.shape[0], 1, 1)
+    )
+
+    matrix[:, 2, 2] = co * torch.exp(1j * gamma)
+    matrix[:, 2, 3] = -si * torch.exp(1j * (lam + gamma))
+    matrix[:, 3, 2] = si * torch.exp(1j * (phi + gamma))
+    matrix[:, 3, 3] = co * torch.exp(1j * (phi + lam + gamma))
+
+    return matrix.squeeze(0)
 
 def qubitunitary_matrix(params):
     """Compute unitary matrix for Qubitunitary gate.
@@ -1190,6 +1225,7 @@ def singleexcitation_matrix(params):
     "cu1": cu1_matrix,
     "cu2": cu2_matrix,
     "cu3": cu3_matrix,
+    "cu": cu_matrix,
     "qubitunitary": qubitunitary_matrix,
     "qubitunitaryfast": qubitunitaryfast_matrix,
     "qubitunitarystrict": qubitunitarystrict_matrix,
@@ -2891,6 +2927,53 @@ def cu3(
     )
 
 
+def cu(
+    q_device,
+    wires,
+    params=None,
+    n_wires=None,
+    static=False,
+    parent_graph=None,
+    inverse=False,
+    comp_method="bmm",
+):
+    """Perform the cu gate.
+
+    Args:
+        q_device (tq.QuantumDevice): The QuantumDevice.
+        wires (Union[List[int], int]): Which qubit(s) to apply the gate.
+        params (torch.Tensor, optional): Parameters (if any) of the gate.
+            Default to None.
+        n_wires (int, optional): Number of qubits the gate is applied to.
+            Default to None.
+        static (bool, optional): Whether use static mode computation.
+            Default to False.
+        parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of
+            current operation. Default to None.
+        inverse (bool, optional): Whether inverse the gate. Default to False.
+        comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform
+        matrix vector multiplication. Default to 'bmm'.
+
+    Returns:
+        None.
+
+    """
+    name = "cu"
+    mat = mat_dict[name]
+    gate_wrapper(
+        name=name,
+        mat=mat,
+        method=comp_method,
+        q_device=q_device,
+        wires=wires,
+        params=params,
+        n_wires=n_wires,
+        static=static,
+        parent_graph=parent_graph,
+        inverse=inverse,
+    )
+
+
 def qubitunitary(
     q_device,
     wires,
@@ -3234,7 +3317,6 @@ def ecr(
 ccnot = toffoli
 ccx = toffoli
 u = u3
-cu = cu3
 p = phaseshift
 cp = cu1
 cr = cu1

torchquantum/operators.py

@@ -56,6 +56,7 @@
     "CU1",
     "CU2",
     "CU3",
+    "CU",
     "QubitUnitary",
     "QubitUnitaryFast",
     "TrainableUnitary",
@@ -145,6 +146,7 @@ class Operator(tq.QuantumModule):
         "CU1",
         "CU2",
         "CU3",
+        "CU",
         "QubitUnitary",
         "QubitUnitaryFast",
         "TrainableUnitary",
@@ -1102,6 +1104,16 @@ class CU3(Operation, metaclass=ABCMeta):
     def _matrix(cls, params):
         return tqf.cu3_matrix(params)
 
+class CU(Operation, metaclass=ABCMeta):
+    """Class for Controlled U gate (4-parameter two-qubit gate)."""
+
+    num_params = 4
+    num_wires = 2
+    func = staticmethod(tqf.cu)
+
+    @classmethod
+    def _matrix(cls, params):
+        return tqf.cu_matrix(params)
 
 class QubitUnitary(Operation, metaclass=ABCMeta):
     """Class for controlled Qubit Unitary gate."""
@@ -1376,7 +1388,7 @@ def _matrix(cls, params):
     "cphase": CU1,
     "cu2": CU2,
     "cu3": CU3,
-    "cu": CU3,
+    "cu": CU,
     "qubitunitary": QubitUnitary,
     "qubitunitarystrict": QubitUnitaryFast,
     "qubitunitaryfast": QubitUnitaryFast,