Implement multi-controlled U1 as gate

qiskit/circuit/add_control.py

@@ -90,11 +90,10 @@ def control(operation: Union[Gate, ControlledGate],
     # pylint: disable=unused-import
     import qiskit.extensions.standard.multi_control_rotation_gates
     import qiskit.extensions.standard.multi_control_toffoli_gate
-    import qiskit.extensions.standard.multi_control_u1_gate
 
     q_control = QuantumRegister(num_ctrl_qubits, name='control')
     q_target = QuantumRegister(operation.num_qubits, name='target')
-    q_ancillae = None  # TODO: add
+    # q_ancillae = None  # TODO: add
     qc = QuantumCircuit(q_control, q_target)
 
     if operation.name == 'x' or (
@@ -109,7 +108,7 @@ def control(operation: Union[Gate, ControlledGate],
                 use_basis_gates=True)
     elif operation.name == 'ry':
         qc.mcry(operation.definition[0][0].params[0], q_control, q_target[0],
-                q_ancillae, use_basis_gates=True)
+                None, mode='noancilla', use_basis_gates=True)
     elif operation.name == 'rz':
         qc.mcrz(operation.definition[0][0].params[0], q_control, q_target[0],
                 use_basis_gates=True)
@@ -124,15 +123,15 @@ def control(operation: Union[Gate, ControlledGate],
                             use_basis_gates=True)
                 elif phi == 0 and lamb == 0:
                     qc.mcry(theta, q_control, q_target[rule[1][0].index],
-                            q_ancillae, mode='noancilla', use_basis_gates=True)
+                            None, mode='noancilla', use_basis_gates=True)
                 elif theta == 0 and phi == 0:
                     qc.mcrz(lamb, q_control, q_target[rule[1][0].index],
                             use_basis_gates=True)
                 else:
                     qc.mcrz(lamb, q_control, q_target[rule[1][0].index],
                             use_basis_gates=True)
                     qc.mcry(theta, q_control, q_target[rule[1][0].index],
-                            q_ancillae, use_basis_gates=True)
+                            None, mode='noancilla', use_basis_gates=True)
                     qc.mcrz(phi, q_control, q_target[rule[1][0].index],
                             use_basis_gates=True)
             elif rule[0].name == 'u1':

qiskit/extensions/standard/__init__.py

@@ -28,15 +28,14 @@
 from .s import SGate, SdgGate
 from .swap import SwapGate, CSwapGate
 from .t import TGate, TdgGate
-from .u1 import U1Gate, CU1Gate
+from .u1 import U1Gate, CU1Gate, MCU1Gate
 from .u2 import U2Gate
 from .u3 import U3Gate, CU3Gate
 from .x import XGate, CXGate, CCXGate
 from .y import YGate, CYGate
 from .z import ZGate, CZGate
 
 # to be converted to gates
-from .multi_control_u1_gate import mcu1
 from .multi_control_toffoli_gate import mct
 from .multi_control_rotation_gates import mcrx, mcry, mcrz
 

qiskit/extensions/standard/u1.py

@@ -57,6 +57,7 @@ def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None):
         if ctrl_state is None:
             if num_ctrl_qubits == 1:
                 return CU1Gate(*self.params)
+            return MCU1Gate(*self.params, num_ctrl_qubits)
         return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label,
                                ctrl_state=ctrl_state)
 
@@ -143,6 +144,23 @@ def _define(self):
             definition.append(inst)
         self.definition = definition
 
+    def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None):
+        """Controlled version of this gate.
+
+        Args:
+            num_ctrl_qubits (int): number of control qubits.
+            label (str or None): An optional label for the gate [Default: None]
+            ctrl_state (int or str or None): control state expressed as integer,
+                string (e.g. '110'), or None. If None, use all 1s.
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if ctrl_state is None:
+            return MCU1Gate(*self.params, num_ctrl_qubits + 1)
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label,
+                               ctrl_state=ctrl_state)
+
     def inverse(self):
         """Invert this gate."""
         return CU1Gate(-self.params[0])
@@ -185,3 +203,137 @@ def cu1(self, theta, control_qubit, target_qubit,
 
 
 QuantumCircuit.cu1 = cu1
+
+
+class MCU1Gate(ControlledGate):
+    """The multi-controlled U1 gate."""
+
+    def __init__(self, lam, num_ctrl_qubits):
+        """Create a new MCU1s gate."""
+        super().__init__('mcu1', num_ctrl_qubits + 1, [lam], num_ctrl_qubits=num_ctrl_qubits)
+        self.base_gate = U1Gate(lam)
+
+    def _define(self):
+        """The gate definition of the multi-controlled U1 gate.
+
+        Ported from Aqua (github.com/Qiskit/qiskit-aqua),
+        commit 769ca8d, file qiskit/aqua/circuits/gates/multi_control_u1_gate.py.
+        """
+        definition = []
+        q = QuantumRegister(self.num_qubits, 'q')
+        q_controls = q[:self.num_ctrl_qubits]
+        q_target = q[self.num_ctrl_qubits]
+        lam = self.params[0]
+        if self.num_ctrl_qubits == 0:
+            definition.append(
+                (U1Gate(lam), [q_target], [])
+            )
+        elif self.num_ctrl_qubits == 1:
+            definition.append(
+                (CU1Gate(lam), q_controls + [q_target], [])
+            )
+        else:
+            from qiskit.extensions.standard.x import CXGate
+            from sympy.combinatorics.graycode import GrayCode
+            gray_code = list(GrayCode(self.num_ctrl_qubits).generate_gray())
+            last_pattern = None
+
+            lam_angle = lam * (1 / (2**(self.num_ctrl_qubits - 1)))
+
+            for pattern in gray_code:
+                if '1' not in pattern:
+                    continue
+                if last_pattern is None:
+                    last_pattern = pattern
+                # find left most set bit
+                lm_pos = list(pattern).index('1')
+
+                # find changed bit
+                comp = [i != j for i, j in zip(pattern, last_pattern)]
+                if True in comp:
+                    pos = comp.index(True)
+                else:
+                    pos = None
+                if pos is not None:
+                    if pos != lm_pos:
+                        definition.append(
+                            (CXGate(), [q_controls[pos], q_controls[lm_pos]], [])
+                        )
+                    else:
+                        indices = [i for i, x in enumerate(pattern) if x == '1']
+                        for idx in indices[1:]:
+                            definition.append(
+                                (CXGate(), [q_controls[idx], q_controls[lm_pos]], [])
+                            )
+                # check parity
+                if pattern.count('1') % 2 == 0:
+                    # inverse
+                    definition.append(
+                        (CU1Gate(-lam_angle), [q_controls[lm_pos], q_target], [])
+                    )
+                else:
+                    definition.append(
+                        (CU1Gate(lam_angle), [q_controls[lm_pos], q_target], [])
+                    )
+                last_pattern = pattern
+
+        self.definition = definition
+
+    def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None):
+        """Controlled version of this gate.
+
+        Args:
+            num_ctrl_qubits (int): number of control qubits.
+            label (str or None): An optional label for the gate [Default: None]
+            ctrl_state (int or str or None): control state expressed as integer,
+                string (e.g. '110'), or None. If None, use all 1s.
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if ctrl_state is None:
+            return MCU1Gate(*self.params, self.num_ctrl_qubits + num_ctrl_qubits)
+        return super().control(num_ctrl_qubits=self.num_ctrl_qubits + num_ctrl_qubits,
+                               label=label,
+                               ctrl_state=ctrl_state)
+
+    def inverse(self):
+        """Invert this gate."""
+        return MCU1Gate(-self.params[0], self.num_ctrl_qubits)
+
+    def to_matrix(self):
+        """Return a numpy.array for the multi-controlled U1 gate."""
+        lam = self.params[0]
+        if self.num_ctrl_qubits == 0:
+            return U1Gate(lam).to_matrix()
+        if self.num_ctrl_qubits == 1:
+            return CU1Gate(lam).to_matrix()
+
+        from qiskit.extensions.unitary import _compute_control_matrix
+        base_mat = U1Gate(lam).to_matrix()
+        return _compute_control_matrix(base_mat, self.num_ctrl_qubits)
+
+
+def mcu1(self, lam, control_qubits, target_qubit):
+    """Apply multi-cU1 gate from specified controls (control_qubits) to target (target_qubit) qubit
+    with angle ``lam``. A multi-cU1 gate implements a ``lam`` radian rotation of the qubit state
+    vector about the z axis of the Bloch sphere when the control qubits are all in state |1>.
+
+    Examples:
+
+        Circuit Representation:
+
+        .. jupyter-execute::
+
+            from qiskit.circuit import QuantumCircuit, Parameter
+
+            lam = Parameter('λ')
+            circuit = QuantumCircuit(4)
+            circuit.mcu1(lam, [0, 1, 2], 3)
+            circuit.draw()
+    """
+    num_ctrl_qubits = len(control_qubits)
+    return self.append(MCU1Gate(lam, num_ctrl_qubits), control_qubits[:] + [target_qubit], [])
+
+
+QuantumCircuit.mcu1 = mcu1