add global_phase to QuantumCircuit class

qiskit/circuit/add_control.py

@@ -99,57 +99,75 @@ def control(operation: Union[Gate, ControlledGate],
     from math import pi
     # pylint: disable=cyclic-import
     import qiskit.circuit.controlledgate as controlledgate
-    # pylint: disable=unused-import
-    import qiskit.circuit.library.standard_gates.multi_control_rotation_gates
 
     q_control = QuantumRegister(num_ctrl_qubits, name='control')
     q_target = QuantumRegister(operation.num_qubits, name='target')
     q_ancillae = None  # TODO: add
-    qc = QuantumCircuit(q_control, q_target)
-
+    controlled_circ = QuantumCircuit(q_control, q_target,
+                                     name='c_{}'.format(operation.name))
+    global_phase = 0
     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], q_ancillae)
-    elif operation.name == 'rx':
-        qc.mcrx(operation.definition.data[0][0].params[0], q_control, q_target[0],
-                use_basis_gates=True)
-    elif operation.name == 'ry':
-        qc.mcry(operation.definition.data[0][0].params[0], q_control, q_target[0],
-                q_ancillae, mode='noancilla', use_basis_gates=True)
-    elif operation.name == 'rz':
-        qc.mcrz(operation.definition.data[0][0].params[0], q_control, q_target[0],
-                use_basis_gates=True)
+        controlled_circ.mct(q_control[:] + q_target[:-1], q_target[-1], q_ancillae)
+        if operation.definition is not None and operation.definition.global_phase:
+            global_phase += operation.definition.global_phase
     else:
-        bgate = _unroll_gate(operation, ['u1', 'u3', 'cx'])
-        # now we have a bunch of single qubit rotation gates and cx
-        for rule in bgate.definition.data:
-            if rule[0].name == 'u3':
-                theta, phi, lamb = rule[0].params
+        basis = ['u1', 'u3', 'x', 'rx', 'ry', 'rz', 'cx']
+        unrolled_gate = _unroll_gate(operation, basis_gates=basis)
+        for gate, qreg, _ in unrolled_gate.definition.data:
+            if gate.name == 'x':
+                controlled_circ.mct(q_control, q_target[qreg[0].index],
+                                    q_ancillae)
+            elif gate.name == 'rx':
+                controlled_circ.mcrx(gate.definition.data[0][0].params[0],
+                                     q_control, q_target[qreg[0].index],
+                                     use_basis_gates=True)
+            elif gate.name == 'ry':
+                controlled_circ.mcry(gate.definition.data[0][0].params[0],
+                                     q_control, q_target[qreg[0].index],
+                                     q_ancillae, mode='noancilla',
+                                     use_basis_gates=True)
+            elif gate.name == 'rz':
+                controlled_circ.mcrz(gate.definition.data[0][0].params[0],
+                                     q_control, q_target[qreg[0].index],
+                                     use_basis_gates=True)
+            elif gate.name == 'u1':
+                controlled_circ.mcu1(gate.params[0], q_control, q_target[qreg[0].index])
+            elif gate.name == 'cx':
+                controlled_circ.mct(q_control[:] + [q_target[qreg[0].index]],
+                                    q_target[qreg[1].index],
+                                    q_ancillae)
+            elif gate.name == 'u3':
+                theta, phi, lamb = gate.params
                 if phi == -pi / 2 and lamb == pi / 2:
-                    qc.mcrx(theta, q_control, q_target[rule[1][0].index],
-                            use_basis_gates=True)
+                    controlled_circ.mcrx(theta, q_control, q_target[qreg[0].index],
+                                         use_basis_gates=True)
                 elif phi == 0 and lamb == 0:
-                    qc.mcry(theta, q_control, q_target[rule[1][0].index],
-                            q_ancillae, use_basis_gates=True)
+                    controlled_circ.mcry(theta, q_control, q_target[qreg[0].index],
+                                         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)
+                    controlled_circ.mcrz(lamb, q_control, q_target[qreg[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)
-                    qc.mcrz(phi, q_control, q_target[rule[1][0].index],
-                            use_basis_gates=True)
-            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],
-                       q_ancillae)
+                    controlled_circ.mcrz(lamb, q_control, q_target[qreg[0].index],
+                                         use_basis_gates=True)
+                    controlled_circ.mcry(theta, q_control, q_target[qreg[0].index],
+                                         q_ancillae, use_basis_gates=True)
+                    controlled_circ.mcrz(phi, q_control, q_target[qreg[0].index],
+                                         use_basis_gates=True)
             else:
-                raise CircuitError('gate contains non-controllable instructions')
-
+                raise CircuitError('gate contains non-controllable instructions: {}'.format(
+                    gate.name))
+            if gate.definition is not None and gate.definition.global_phase:
+                global_phase += gate.definition.global_phase
+    # apply controlled global phase
+    if ((operation.definition is not None and operation.definition.global_phase) or global_phase):
+        if len(q_control) < 2:
+            controlled_circ.u1(operation.definition.global_phase + global_phase, q_control)
+        else:
+            controlled_circ.mcu1(operation.definition.global_phase + global_phase,
+                                 q_control[:-1], q_control[-1])
     if isinstance(operation, controlledgate.ControlledGate):
         new_num_ctrl_qubits = num_ctrl_qubits + operation.num_ctrl_qubits
         new_ctrl_state = operation.ctrl_state << num_ctrl_qubits | ctrl_state
@@ -170,11 +188,11 @@ def control(operation: Union[Gate, ControlledGate],
         ctrl_substr = ('{0}' * new_num_ctrl_qubits).format('c')
     new_name = '{0}{1}'.format(ctrl_substr, base_name)
     cgate = controlledgate.ControlledGate(new_name,
-                                          qc.num_qubits,
+                                          controlled_circ.num_qubits,
                                           operation.params,
                                           label=label,
                                           num_ctrl_qubits=new_num_ctrl_qubits,
-                                          definition=qc,
+                                          definition=controlled_circ,
                                           ctrl_state=new_ctrl_state)
     cgate.base_gate = base_gate
     return cgate
@@ -196,7 +214,7 @@ def _gate_to_circuit(operation):
 
 def _gate_to_dag(operation):
     from qiskit.converters.circuit_to_dag import circuit_to_dag
-    if hasattr(operation, 'definition') and operation.definition:
+    if hasattr(operation, 'definition') and operation.definition is not None:
         return circuit_to_dag(operation.definition)
     else:
         qr = QuantumRegister(operation.num_qubits)
@@ -210,5 +228,5 @@ def _unroll_gate(operation, basis_gates):
     from qiskit.transpiler.passes import Unroller
     unroller = Unroller(basis_gates)
     dag = _gate_to_dag(operation)
-    qc = dag_to_circuit(unroller.run(dag))
-    return qc.to_gate()
+    opqc = dag_to_circuit(unroller.run(dag))
+    return opqc.to_gate()

qiskit/circuit/controlledgate.py

@@ -207,4 +207,5 @@ def __eq__(self, other) -> bool:
 
     def inverse(self) -> 'ControlledGate':
         """Invert this gate by calling inverse on the base gate."""
-        return self.base_gate.inverse().control(self.num_ctrl_qubits)
+        return self.base_gate.inverse().control(self.num_ctrl_qubits,
+                                                ctrl_state=self.ctrl_state)

qiskit/circuit/equivalence.py

@@ -258,7 +258,6 @@ def _raise_if_shape_mismatch(gate, circuit):
 
 def _rebind_equiv(equiv, query_params):
     equiv_params, equiv_circuit = equiv
-
     param_map = dict(zip(equiv_params, query_params))
     equiv = equiv_circuit.assign_parameters(param_map, inplace=False)
 

qiskit/circuit/library/standard_gates/equivalence_library.py

@@ -36,6 +36,7 @@
     RZGate,
     CRZGate,
     RZZGate,
+    RZXGate,
     SGate,
     SdgGate,
     SwapGate,
@@ -158,14 +159,30 @@
         (HGate(), [q[0]], []),
         (HGate(), [q[1]], []),
         (CXGate(), [q[0], q[1]], []),
-        (U1Gate(theta), [q[1]], []),
+        (RZGate(theta), [q[1]], []),
         (CXGate(), [q[0], q[1]], []),
         (HGate(), [q[1]], []),
         (HGate(), [q[0]], []),
 ]:
     def_rxx.append(inst, qargs, cargs)
 _sel.add_equivalence(RXXGate(theta), def_rxx)
 
+# RZXGate
+
+q = QuantumRegister(2, 'q')
+theta = Parameter('theta')
+def_rzx = QuantumCircuit(q)
+for inst, qargs, cargs in [
+        (HGate(), [q[1]], []),
+        (CXGate(), [q[0], q[1]], []),
+        (RZGate(theta), [q[1]], []),
+        (CXGate(), [q[0], q[1]], []),
+        (HGate(), [q[1]], []),
+]:
+    def_rzx.append(inst, qargs, cargs)
+_sel.add_equivalence(RZXGate(theta), def_rzx)
+
+
 # RYGate
 
 q = QuantumRegister(1, 'q')
@@ -209,7 +226,7 @@
 
 q = QuantumRegister(1, 'q')
 theta = Parameter('theta')
-def_rz = QuantumCircuit(q)
+def_rz = QuantumCircuit(q, global_phase=-theta / 2)
 def_rz.append(U1Gate(theta), [q[0]], [])
 _sel.add_equivalence(RZGate(theta), def_rz)
 
@@ -242,7 +259,7 @@
 def_rzz = QuantumCircuit(q)
 for inst, qargs, cargs in [
         (CXGate(), [q[0], q[1]], []),
-        (U1Gate(theta), [q[1]], []),
+        (RZGate(theta), [q[1]], []),
         (CXGate(), [q[0], q[1]], [])
 ]:
     def_rzz.append(inst, qargs, cargs)
@@ -338,7 +355,7 @@
 def_tdg.append(U1Gate(-pi / 4), [q[0]], [])
 _sel.add_equivalence(TdgGate(), def_tdg)
 
-# U1Gate
+# U2Gate
 
 q = QuantumRegister(1, 'q')
 phi = Parameter('phi')
@@ -376,7 +393,7 @@
 theta = Parameter('theta')
 phi = Parameter('phi')
 lam = Parameter('lam')
-u3_qasm_def = QuantumCircuit(q)
+u3_qasm_def = QuantumCircuit(q, global_phase=(lam + phi) / 2)
 u3_qasm_def.rz(lam, 0)
 u3_qasm_def.rx(pi/2, 0)
 u3_qasm_def.rz(theta+pi, 0)
@@ -427,7 +444,7 @@
 _sel.add_equivalence(CXGate(), cx_to_cz)
 
 q = QuantumRegister(2, 'q')
-cx_to_iswap = QuantumCircuit(q)
+cx_to_iswap = QuantumCircuit(q, global_phase=3*pi/4)
 for inst, qargs, cargs in [
         (HGate(), [q[0]], []),
         (XGate(), [q[1]], []),

qiskit/circuit/library/standard_gates/ms.py

@@ -39,11 +39,12 @@ def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .rxx import RXXGate
+        theta = self.params[0]
         q = QuantumRegister(self.num_qubits, 'q')
         qc = QuantumCircuit(q, name=self.name)
         rules = []
         for i in range(self.num_qubits):
             for j in range(i + 1, self.num_qubits):
-                rules += [(RXXGate(self.params[0]), [q[i], q[j]], [])]
+                rules += [(RXXGate(theta), [q[i], q[j]], [])]
         qc._data = rules
         self.definition = qc

qiskit/circuit/library/standard_gates/rx.py

@@ -200,18 +200,23 @@ def inverse(self):
         """Return inverse RX gate (i.e. with the negative rotation angle)."""
         return CRXGate(-self.params[0])
 
-    # TODO: this is the correct definition but has a global phase with respect
-    # to the decomposition above. Restore after allowing phase on circuits.
-    # def to_matrix(self):
-    #    """Return a numpy.array for the CRX gate."""
-    #    half_theta = self.params[0] / 2
-    #    cos = numpy.cos(half_theta)
-    #    isin = 1j * numpy.sin(half_theta)
-    #    return numpy.array([[1,     0, 0,     0],
-    #                        [0,   cos, 0, -isin],
-    #                        [0,     0, 1,     0],
-    #                        [0, -isin, 0,   cos]],
-    #                       dtype=complex)
+    def to_matrix(self):
+        """Return a numpy.array for the CRX gate."""
+        half_theta = self.params[0] / 2
+        cos = numpy.cos(half_theta)
+        isin = 1j * numpy.sin(half_theta)
+        if self.ctrl_state:
+            return numpy.array([[1, 0, 0, 0],
+                                [0, cos, 0, -isin],
+                                [0, 0, 1, 0],
+                                [0, -isin, 0, cos]],
+                               dtype=complex)
+        else:
+            return numpy.array([[cos, 0, -isin, 0],
+                                [0, 1, 0, 0],
+                                [-isin, 0, cos, 0],
+                                [0, 0, 0, 1]],
+                               dtype=complex)
 
 
 class CrxGate(CRXGate, metaclass=CRXMeta):

qiskit/circuit/library/standard_gates/rxx.py

@@ -77,16 +77,16 @@ def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .x import CXGate
-        from .u1 import U1Gate
         from .h import HGate
+        from .rz import RZGate
+        theta = self.params[0]
         q = QuantumRegister(2, 'q')
         qc = QuantumCircuit(q, name=self.name)
-        theta = self.params[0]
         rules = [
             (HGate(), [q[0]], []),
             (HGate(), [q[1]], []),
             (CXGate(), [q[0], q[1]], []),
-            (U1Gate(theta), [q[1]], []),
+            (RZGate(theta), [q[1]], []),
             (CXGate(), [q[0], q[1]], []),
             (HGate(), [q[1]], []),
             (HGate(), [q[0]], []),
@@ -98,14 +98,14 @@ def inverse(self):
         """Return inverse RXX gate (i.e. with the negative rotation angle)."""
         return RXXGate(-self.params[0])
 
-    # NOTE: we should use the following as the canonical matrix
-    # definition but we don't include it yet since it differs from
-    # the circuit decomposition matrix by a global phase
-    # def to_matrix(self):
-    #   """Return a Numpy.array for the RXX gate."""
-    #    theta = float(self.params[0])
-    #    return np.array([
-    #        [np.cos(theta / 2), 0, 0, -1j * np.sin(theta / 2)],
-    #        [0, np.cos(theta / 2), -1j * np.sin(theta / 2), 0],
-    #        [0, -1j * np.sin(theta / 2), np.cos(theta / 2), 0],
-    #        [-1j * np.sin(theta / 2), 0, 0, np.cos(theta / 2)]], dtype=complex)
+    def to_matrix(self):
+        """Return a Numpy.array for the RXX gate."""
+        import numpy
+        theta2 = float(self.params[0]) / 2
+        cos = numpy.cos(theta2)
+        isin = 1j * numpy.sin(theta2)
+        return numpy.array([
+            [cos, 0, 0, -isin],
+            [0, cos, -isin, 0],
+            [0, -isin, cos, 0],
+            [-isin, 0, 0, cos]], dtype=complex)

qiskit/circuit/library/standard_gates/ry.py

@@ -195,18 +195,23 @@ def inverse(self):
         """Return inverse RY gate (i.e. with the negative rotation angle)."""
         return CRYGate(-self.params[0])
 
-    # TODO: this is the correct definition but has a global phase with respect
-    # to the decomposition above. Restore after allowing phase on circuits.
-    # def to_matrix(self):
-    #    """Return a numpy.array for the CRY gate."""
-    #    half_theta = self.params[0] / 2
-    #    cos = numpy.cos(half_theta)
-    #    sin = numpy.sin(half_theta)
-    #    return numpy.array([[1,     0, 0,    0],
-    #                        [0,   cos, 0, -sin],
-    #                        [0,     0, 1,    0],
-    #                        [0,   sin, 0,  cos]],
-    #                       dtype=complex)
+    def to_matrix(self):
+        """Return a numpy.array for the CRY gate."""
+        half_theta = self.params[0] / 2
+        cos = numpy.cos(half_theta)
+        sin = numpy.sin(half_theta)
+        if self.ctrl_state:
+            return numpy.array([[1, 0, 0, 0],
+                                [0, cos, 0, -sin],
+                                [0, 0, 1, 0],
+                                [0, sin, 0, cos]],
+                               dtype=complex)
+        else:
+            return numpy.array([[cos, 0, -sin, 0],
+                                [0, 1, 0, 0],
+                                [sin, 0, cos, 0],
+                                [0, 0, 0, 1]],
+                               dtype=complex)
 
 
 class CryGate(CRYGate, metaclass=CRYMeta):