Implement multi-controlled U1 as gate

qiskit/circuit/add_control.py

@@ -90,7 +90,6 @@ 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')
@@ -100,16 +99,13 @@ def control(operation: Union[Gate, ControlledGate],
     if operation.name == 'x' or (
             isinstance(operation, controlledgate.ControlledGate) and
             operation.base_gate.name == 'x'):
-        qc.mct(q_control[:] + q_target[:-1],
-               q_target[-1],
-               None,
-               mode='noancilla')
+        qc.mct(q_control[:] + q_target[:-1], q_target[-1], q_ancillae)
     elif operation.name == 'rx':
         qc.mcrx(operation.definition[0][0].params[0], q_control, q_target[0],
                 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)
+                q_ancillae, 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,7 +120,7 @@ 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)
+                            q_ancillae, 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)
@@ -138,10 +134,8 @@ def control(operation: Union[Gate, ControlledGate],
             elif rule[0].name == 'u1':
                 qc.mcu1(rule[0].params[0], q_control, q_target[rule[1][0].index])
             elif rule[0].name == 'cx':
-                qc.mct(q_control[:] + [q_target[rule[1][0].index]],
-                       q_target[rule[1][1].index],
-                       None,
-                       mode='noancilla')
+                qc.mct(q_control[:] + [q_target[rule[1][0].index]], q_target[rule[1][1].index],
+                       q_ancillae)
             else:
                 raise CircuitError('gate contains non-controllable instructions')
     instr = qc.to_instruction()

qiskit/extensions/standard/__init__.py

@@ -33,15 +33,14 @@
 from .iswap import iSwapGate
 from .dcx import DCXGate
 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/multi_control_rotation_gates.py

@@ -19,6 +19,7 @@
 from math import pi
 from qiskit.circuit import QuantumCircuit, QuantumRegister, Qubit
 from qiskit.exceptions import QiskitError
+from qiskit.extensions.standard.u3 import _generate_gray_code
 
 logger = logging.getLogger(__name__)
 
@@ -35,15 +36,6 @@ def _apply_cu3(circuit, theta, phi, lam, control, target, use_basis_gates=True):
         circuit.cu3(theta, phi, lam, control, target)
 
 
-def _generate_gray_code(num_bits):
-    if num_bits <= 0:
-        raise QiskitError("Must have at least 1 control in a controlled gate")
-    result = [0]
-    for i in range(num_bits):
-        result += [x + 2**i for x in reversed(result)]
-    return [format(x, "0%sb" % num_bits) for x in result]
-
-
 def _apply_mcu3_graycode(circuit, theta, phi, lam, ctls, tgt, use_basis_gates):
     """Apply multi-controlled u3 gate from ctls to tgt using graycode
     pattern with single-step angles theta, phi, lam."""

qiskit/extensions/standard/u1.py

@@ -108,7 +108,8 @@ 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 CU1Gate(self.params[0])
+            return MCU1Gate(self.params[0], num_ctrl_qubits)
         return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label,
                                ctrl_state=ctrl_state)
 
@@ -192,20 +193,38 @@ def _define(self):
           u1(lambda/2) b;
         }
         """
-        from qiskit.extensions.standard.x import CXGate
         definition = []
         q = QuantumRegister(2, 'q')
+        from qiskit.extensions.standard.x import CXGate
         rule = [
             (U1Gate(self.params[0] / 2), [q[0]], []),
             (CXGate(), [q[0], q[1]], []),
             (U1Gate(-self.params[0] / 2), [q[1]], []),
             (CXGate(), [q[0], q[1]], []),
             (U1Gate(self.params[0] / 2), [q[1]], [])
         ]
+
         for inst in rule:
             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[0], num_ctrl_qubits=num_ctrl_qubits + 1)
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label,
+                               ctrl_state=ctrl_state)
+
     def inverse(self):
         r"""Return inverted CU1 gate (:math:`CU1(\lambda){\dagger} = CU1(-\lambda)`)"""
         return CU1Gate(-self.params[0])
@@ -232,3 +251,79 @@ def cu1(self, theta, control_qubit, target_qubit,
 
 
 QuantumCircuit.cu1 = cu1
+
+
+class MCU1Gate(ControlledGate):
+    r"""Multi-controlled-U1 gate.
+
+    This is a diagonal and symmetric gate that induces a
+    phase on the state of the target qubit, depending on the state of the control qubits.
+
+    **Circuit symbol:**
+
+    .. parsed-literal::
+
+            q_0: ────■────
+                     │
+                     .
+                     │
+        q_(n-1): ────■────
+                 ┌───┴───┐
+            q_n: ┤ U1(λ) ├
+                 └───────┘
+
+    .. seealso::
+
+        :class:`~qiskit.extensions.standard.CU1Gate`:
+        The singly-controlled-version of this gate.
+    """
+
+    def __init__(self, lam, num_ctrl_qubits):
+        """Create new MCU1 gate."""
+        super().__init__('mcu1', num_ctrl_qubits + 1, [lam], num_ctrl_qubits=num_ctrl_qubits)
+        self.base_gate = U1Gate(lam)
+
+    def _define(self):
+        q = QuantumRegister(self.num_qubits, 'q')
+
+        if self.num_ctrl_qubits == 0:
+            definition = U1Gate(self.params[0]).definition
+        if self.num_ctrl_qubits == 1:
+            definition = CU1Gate(self.params[0]).definition
+        else:
+            from qiskit.extensions.standard.u3 import _gray_code_chain
+            scaled_lam = self.params[0] / (2 ** (self.num_ctrl_qubits - 1))
+            bottom_gate = CU1Gate(scaled_lam)
+            definition = _gray_code_chain(q, self.num_ctrl_qubits, bottom_gate)
+
+        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[0], num_ctrl_qubits=num_ctrl_qubits + self.num_ctrl_qubits)
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label,
+                               ctrl_state=ctrl_state)
+
+    def inverse(self):
+        r"""Return inverted MCU1 gate (:math:`MCU1(\lambda){\dagger} = MCU1(-\lambda)`)"""
+        return MCU1Gate(-self.params[0], self.num_ctrl_qubits)
+
+
+def mcu1(self, lam, control_qubits, target_qubit):
+    """Apply :class:`~qiskit.extensions.standard.CU1Gate`."""
+    num_ctrl_qubits = len(control_qubits)
+    return self.append(MCU1Gate(lam, num_ctrl_qubits), control_qubits[:] + [target_qubit], [])
+
+
+QuantumCircuit.mcu1 = mcu1

qiskit/extensions/standard/u3.py

@@ -248,3 +248,67 @@ def cu3(self, theta, phi, lam, control_qubit, target_qubit,
 
 
 QuantumCircuit.cu3 = cu3
+
+
+def _generate_gray_code(num_bits):
+    """Generate the gray code for ``num_bits`` bits."""
+    if num_bits <= 0:
+        raise ValueError('Cannot generate the gray code for less than 1 bit.')
+    result = [0]
+    for i in range(num_bits):
+        result += [x + 2**i for x in reversed(result)]
+    return [format(x, '0%sb' % num_bits) for x in result]
+
+
+def _gray_code_chain(q, num_ctrl_qubits, gate):
+    """Apply the gate to the the last qubit in the register ``q``, controlled on all
+    preceding qubits. This function uses the gray code to propagate down to the last qubit.
+
+    Ported and adapted from Aqua (github.com/Qiskit/qiskit-aqua),
+    commit 769ca8d, file qiskit/aqua/circuits/gates/multi_control_u1_gate.py.
+    """
+    from qiskit.extensions.standard.x import CXGate
+
+    rule = []
+    q_controls, q_target = q[:num_ctrl_qubits], q[num_ctrl_qubits]
+    gray_code = _generate_gray_code(num_ctrl_qubits)
+    last_pattern = None
+
+    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:
+                rule.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:]:
+                    rule.append(
+                        (CXGate(), [q_controls[idx], q_controls[lm_pos]], [])
+                    )
+        # check parity
+        if pattern.count('1') % 2 == 0:
+            # inverse
+            rule.append(
+                (gate.inverse(), [q_controls[lm_pos], q_target], [])
+            )
+        else:
+            rule.append(
+                (gate, [q_controls[lm_pos], q_target], [])
+            )
+        last_pattern = pattern
+
+    return rule