Feat new gate

mpqp/__init__.py

@@ -37,6 +37,7 @@
     CNOT,
     CP,
     CZ,
+    PRX,
     SWAP,
     TOF,
     ControlledGate,
@@ -53,8 +54,11 @@
     Rk,
     Rk_dagger,
     Rx,
+    Rxx,
     Ry,
+    Ryy,
     Rz,
+    Rzz,
     S,
     S_dagger,
     T,

mpqp/core/instruction/gates/__init__.py

@@ -1,25 +1,30 @@
 # pyright: reportUnusedImport=false
 from .controlled_gate import ControlledGate
-from .custom_gate import CustomGate, UnitaryMatrix
 from .custom_controlled_gate import CustomControlledGate
+from .custom_gate import CustomGate, UnitaryMatrix
 from .gate import Gate
 from .gate_definition import GateDefinition
 from .native_gates import (
     CNOT,
+    CP,
     CZ,
+    PRX,
     SWAP,
     TOF,
+    ComposedGate,
     CRk,
     CRk_dagger,
     H,
     Id,
     P,
-    CP,
     Rk,
     Rk_dagger,
     Rx,
+    Rxx,
     Ry,
+    Ryy,
     Rz,
+    Rzz,
     S,
     S_dagger,
     T,

mpqp/core/instruction/gates/custom_controlled_gate.py

@@ -34,11 +34,13 @@ class CustomControlledGate(ControlledGate):
         >>> circuit = QCircuit(3)
         >>> circuit.add(CustomControlledGate([0,2], CustomGate(np.array([[1,0],[0,-1]]),[1])))
         >>> print(circuit)  # doctest: +NORMALIZE_WHITESPACE
-        q_0: ─────■─────
-             ┌────┴────┐
-        q_1: ┤ Unitary ├
-             └────┬────┘
-        q_2: ─────■─────
+             ┌──────────┐
+        q_0: ┤2         ├
+             │          │
+        q_1: ┤1 Unitary ├
+             │          │
+        q_2: ┤0         ├
+             └──────────┘
 
     """
 
@@ -85,21 +87,34 @@ def to_other_language(
         language: Language = Language.QISKIT,
         qiskit_parameters: Optional[set["Parameter"]] = None,
     ) -> Any:
+        if isinstance(self.non_controlled_gate, CustomGate):
+            return self.to_custom_gate().to_other_language(language)
         if language == Language.QISKIT:
+
             from qiskit.quantum_info import Operator
 
             gate = self.non_controlled_gate.to_other_language()
             if isinstance(gate, Operator):
                 gate = gate.to_instruction()
             gate = gate.control(len(self.controls))
             return gate
-        elif language == Language.QASM2:
-            if isinstance(self.non_controlled_gate, CustomGate):
-                targets = self.targets + self.controls
-                targets.sort()
-                gate = CustomGate(self.to_matrix(), targets)
+        elif language == Language.CIRQ:
+
+            from cirq import ControlledGate as cirqControlledGate
 
-                return gate.to_other_language(Language.QASM2)
+            return cirqControlledGate(
+                sub_gate=self.non_controlled_gate.to_other_language(Language.CIRQ),
+                num_controls=len(self.controls),
+            )
+        elif language == Language.BRAKET:
+            from braket.circuits import Instruction as BraketInstruction
+
+            return BraketInstruction(
+                operator=self.non_controlled_gate.to_other_language(language).operator,
+                target=self.targets,
+                control=self.controls,
+            )
+        elif language == Language.QASM2:
 
             from qiskit import QuantumCircuit, qasm2
 

mpqp/core/instruction/gates/custom_gate.py

@@ -129,12 +129,11 @@ def to_other_language(
                 from qiskit import QuantumCircuit
 
                 dummy_circuit = QuantumCircuit(self.nb_qubits)
-                for param in qiskit_parameters:
-                    # Rx is just a random choice so to have the parameter in the
-                    # list of inputs
-                    dummy_circuit.rx(param, 0)
-                return dummy_circuit.to_gate(label="CustomGate")
-            return UnitaryGate(self.matrix)
+                dummy_circuit.id(0)
+                return dummy_circuit.to_gate(
+                    label=f"CustomGate({', '.join([str(s) for s in gate_symbols])})"
+                )
+            return UnitaryGate(self.matrix, label=self.label, check_input=False)
         elif language == Language.BRAKET:
             from sympy import Expr
 
@@ -162,32 +161,9 @@ def to_other_language(
                     target=self.targets,
                 )
         elif language == Language.CIRQ:
-            from cirq import Gate as cirqGate
-
-            # TODO: find clean way of initiating this class once
-            # Cost is negli
-            class cirqCustomGate(cirqGate):
-                def __init__(self, matrix: Matrix, label: str | None):
-                    import numpy as np
-
-                    self.matrix = matrix
-                    self.label = label
-                    self._nb_qubits = int(np.log2(len(matrix)))
-                    super(cirqCustomGate, self)
-
-                def _num_qubits_(self) -> int:
-                    return self._nb_qubits
-
-                def _unitary_(self) -> Matrix:
-                    return self.matrix
-
-                def _circuit_diagram_info_(self, args: list[float]) -> str | list[str]:
-                    # we keep args for later implementation
-                    if self.label:
-                        return [self.label] * self._nb_qubits
-                    return ["CustomGate"] * self._nb_qubits
+            from cirq import MatrixGate
 
-            return cirqCustomGate(self.matrix, self.label)
+            return MatrixGate(matrix=self.matrix, name=self.label, unitary_check=False)
 
         elif language == Language.QASM2:
             from qiskit import QuantumCircuit, qasm2
@@ -209,9 +185,7 @@ def _circuit_diagram_info_(self, args: list[float]) -> str | list[str]:
                 self.label,
             )
 
-            circuit, gphase = replace_custom_gate(
-                qiskit_circ.data[0], nb_qubits, self.targets
-            )
+            circuit, gphase = replace_custom_gate(qiskit_circ, nb_qubits, self.targets)
 
             qasm_str = qasm2.dumps(circuit)
             qasm_lines = qasm_str.splitlines()
@@ -251,7 +225,22 @@ def decompose(self) -> "QCircuit":
         """
         from mpqp.tools.unitary_decomposition import quantum_shannon_decomposition
 
-        return quantum_shannon_decomposition(self.matrix)
+        # non ordered targets
+        if any(
+            self.targets[i + 1] < self.targets[i] for i in range(len(self.targets) - 1)
+        ):
+            from copy import deepcopy
+
+            from mpqp.tools import rearrange_matrix
+
+            targets = deepcopy(self.targets)
+            targets.sort()
+
+            return quantum_shannon_decomposition(
+                rearrange_matrix(self.matrix, self.targets, copy=True), targets
+            )
+
+        return quantum_shannon_decomposition(self.matrix, self.targets)
 
     def subs(self, values: dict[Expr | str, Complex]) -> CustomGate:
         res = copy(self)