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,10 +99,7 @@ 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)
@@ -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

@@ -40,7 +40,6 @@
 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

@@ -55,8 +55,7 @@ def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None):
             ControlledGate: controlled version of this gate.
         """
         if ctrl_state is None:
-            if num_ctrl_qubits == 1:
-                return CU1Gate(*self.params)
+            return CU1Gate(*self.params, num_ctrl_qubits)
         return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label,
                                ctrl_state=ctrl_state)
 
@@ -119,9 +118,9 @@ def __instancecheck__(mcs, inst):
 class CU1Gate(ControlledGate, metaclass=CU1Meta):
     """The controlled-u1 gate."""
 
-    def __init__(self, theta):
+    def __init__(self, theta, num_ctrl_qubits=1):
         """Create new cu1 gate."""
-        super().__init__('cu1', 2, [theta], num_ctrl_qubits=1)
+        super().__init__('cu1', num_ctrl_qubits + 1, [theta], num_ctrl_qubits=num_ctrl_qubits)
         self.base_gate = U1Gate(theta)
 
     def _define(self):
@@ -132,23 +131,57 @@ def _define(self):
           u1(lambda/2) b;
         }
         """
-        from qiskit.extensions.standard.x import CXGate
         definition = []
-        q = QuantumRegister(2, 'q')
-        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]], [])
-        ]
+        q = QuantumRegister(self.num_qubits, 'q')
+        if self.num_ctrl_qubits == 1:
+            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]], [])
+            ]
+        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)
+            rule = _gray_code_chain(q, self.num_ctrl_qubits, bottom_gate)
+
         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 CU1Gate(*self.params, num_ctrl_qubits=self.num_ctrl_qubits + num_ctrl_qubits)
+        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])
+        return CU1Gate(-self.params[0], num_ctrl_qubits=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()
+
+        from qiskit.extensions.unitary import _compute_control_matrix
+        base_mat = U1Gate(lam).to_matrix()
+        return _compute_control_matrix(base_mat, self.num_ctrl_qubits, ctrl_state=self.ctrl_state)
 
 
 class Cu1Gate(CU1Gate, metaclass=CU1Meta):
@@ -191,3 +224,31 @@ def cu1(self, theta, control_qubit, target_qubit,
 
 
 QuantumCircuit.cu1 = cu1
+
+
+def mcu1(self, lam, control_qubits, target_qubit):
+    r"""Apply multi-cU1 gate.
+
+    Applied from a specified controls ``control_qubits`` to target
+    ``target_qubit`` qubit  with angle ``lam``. A multi-cU1 gate implements a
+    :math:`\lambda` radian rotation of the qubit state vector about the z axis
+    of the Bloch sphere when all control qubits are in state :math:`|1\rangle`.
+
+    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(CU1Gate(lam, num_ctrl_qubits), control_qubits[:] + [target_qubit], [])
+
+
+QuantumCircuit.mcu1 = mcu1

qiskit/extensions/standard/u3.py

@@ -199,3 +199,58 @@ def cu3(self, theta, phi, lam, control_qubit, target_qubit,
 
 
 QuantumCircuit.cu3 = cu3
+
+
+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
+    from sympy.combinatorics.graycode import GrayCode
+
+    rule = []
+    q_controls, q_target = q[:num_ctrl_qubits], q[num_ctrl_qubits]
+    gray_code = list(GrayCode(num_ctrl_qubits).generate_gray())
+    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

test/python/circuit/test_controlled_gate.py

@@ -345,9 +345,10 @@ def test_multi_control_toffoli_matrix_clean_ancillas(self, num_controls):
             qc.add_register(q_ancillas)
         else:
             num_ancillas = 0
+            q_ancillas = None
 
         # apply hadamard on control qubits and toffoli gate
-        qc.mct(q_controls, q_target[0], None, mode='basic')
+        qc.mct(q_controls, q_target[0], q_ancillas, mode='basic')
 
         # execute the circuit and obtain statevector result
         backend = BasicAer.get_backend('unitary_simulator')
@@ -703,8 +704,8 @@ def test_base_gate_setting(self):
         params = [0.1 * i for i in range(10)]
         for gate_class in ControlledGate.__subclasses__():
             sig = signature(gate_class.__init__)
-            free_params = len(sig.parameters) - 1  # subtract "self"
-            base_gate = gate_class(*params[0:free_params])
+            free_params = len(set(sig.parameters) - {'self', 'num_ctrl_qubits'})
+            base_gate = gate_class(*params[:free_params])
             cgate = base_gate.control()
             self.assertEqual(base_gate.base_gate, cgate.base_gate)
 
@@ -738,9 +739,8 @@ def test_all_inverses(self):
 
     @data(1, 2, 3)
     def test_controlled_standard_gates(self, num_ctrl_qubits):
-        """Test the controlled versions of all standard gates."""
-        gate_classes = [cls for name, cls in allGates.__dict__.items()
-                        if isinstance(cls, type)]
+        """Test controlled versions of all standard gates."""
+        gate_classes = [cls for cls in allGates.__dict__.values() if isinstance(cls, type)]
         theta = pi / 2
         for cls in gate_classes:
             with self.subTest(i=cls):
@@ -752,6 +752,7 @@ def test_controlled_standard_gates(self, num_ctrl_qubits):
                 args = [theta] * numargs
                 if cls in [MSGate, Barrier]:
                     args[0] = 2
+
                 gate = cls(*args)
                 try:
                     cgate = gate.control(num_ctrl_qubits)

test/python/circuit/test_gate_definitions.py

@@ -140,7 +140,8 @@ class TestStandardEquivalenceLibrary(QiskitTestCase):
     def test_definition_parameters(self, gate_class):
         """Verify decompositions from standard equivalence library match definitions."""
 
-        n_params = len(set(signature(gate_class.__init__).parameters) - {'label', 'self'})
+        non_param_attributes = {'self', 'label', 'num_ctrl_qubits'}
+        n_params = len(set(signature(gate_class.__init__).parameters) - non_param_attributes)
         param_vector = ParameterVector('th', n_params)
         float_vector = [0.1 * i for i in range(n_params)]