add global_phase to QuantumCircuit class

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

@@ -275,7 +275,7 @@
 
 q = QuantumRegister(2, 'q')
 theta = Parameter('theta')
-def_ryy = QuantumCircuit(q)
+def_ryy = QuantumCircuit(q, phase=theta / 2)
 for inst, qargs, cargs in [
         (RXGate(pi / 2), [q[0]], []),
         (RXGate(pi / 2), [q[1]], []),
@@ -293,7 +293,7 @@
 q = QuantumRegister(1, 'q')
 theta = Parameter('theta')
 def_rz = QuantumCircuit(q)
-def_rz.append(U1Gate(theta), [q[0]], [])
+def_rz.append(U1Gate(theta), [q[0]], [], phase=-theta / 2)
 _sel.add_equivalence(RZGate(theta), def_rz)
 
 # CRZGate
@@ -413,7 +413,7 @@
 def_tdg.append(U1Gate(-pi / 4), [q[0]], [])
 _sel.add_equivalence(TdgGate(), def_tdg)
 
-# U1Gate
+# U2Gate
 
 q = QuantumRegister(1, 'q')
 phi = Parameter('phi')

qiskit/circuit/library/standard_gates/ryy.py

@@ -16,7 +16,6 @@
 
 import numpy as np
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class RYYGate(Gate):
@@ -75,38 +74,27 @@ def __init__(self, theta):
 
     def _define(self):
         """Calculate a subcircuit that implements this unitary."""
-        from .x import CXGate
-        from .rx import RXGate
-        from .rz import RZGate
-
-        definition = []
-        q = QuantumRegister(2, 'q')
-        theta = self.params[0]
-        rule = [
-            (RXGate(np.pi / 2), [q[0]], []),
-            (RXGate(np.pi / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RZGate(theta), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RXGate(-np.pi / 2), [q[0]], []),
-            (RXGate(-np.pi / 2), [q[1]], []),
-        ]
-        for inst in rule:
-            definition.append(inst)
-        self.definition = definition
+        circ = self.decompositions[0]
+        phase = circ.phase / len(circ.qregs[0])
+        if circ.phase:
+            circ.u3(np.pi, phase, phase - np.pi, circ.qregs[0])
+            circ.x(circ.qregs[0])
+        self.definition = circ.to_gate().definition
 
     def inverse(self):
         """Return inverse RYY gate (i.e. with the negative rotation angle)."""
         return RYYGate(-self.params[0])
 
     # TODO: this is the correct matrix and is equal to the definition above,
     # however the control mechanism cannot distinguish U1 and RZ yet.
-    # def to_matrix(self):
-    #     """Return a numpy.array for the RYY gate."""
-    #     theta = self.params[0]
-    #     return np.exp(0.5j * theta) * 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 RYY gate."""
+        theta = self.params[0]
+        halfcos = np.cos(theta / 2)
+        halfsin = np.sin(theta / 2)
+        return np.exp(0.5j * theta) * np.array([
+            [halfcos, 0, 0, 1j * halfsin],
+            [0, halfcos, -1j * halfsin, 0],
+            [0, -1j * halfsin, halfcos, 0],
+            [1j * halfsin, 0, 0, halfcos]
+        ], dtype=complex)

qiskit/circuit/library/standard_gates/rz.py

@@ -64,15 +64,12 @@ def _define(self):
         """
         gate rz(phi) a { u1(phi) a; }
         """
-        from .u1 import U1Gate
-        definition = []
-        q = QuantumRegister(1, 'q')
-        rule = [
-            (U1Gate(self.params[0]), [q[0]], [])
-        ]
-        for inst in rule:
-            definition.append(inst)
-        self.definition = definition
+        import numpy as np
+        circ = self.decompositions[0]
+        if circ.phase:
+            circ.u3(np.pi, circ.phase, circ.phase - np.pi, circ.qregs[0])
+            circ.x(circ.qregs[0])
+        self.definition = circ.to_gate().definition
 
     def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None):
         """Return a (mutli-)controlled-RZ gate.
@@ -101,12 +98,12 @@ def inverse(self):
 
     # TODO: this is the correct matrix however the control mechanism
     # cannot distinguish U1 and RZ yet.
-    # def to_matrix(self):
-    #    """Return a numpy.array for the RZ gate."""
-    #    import numpy
-    #    lam = float(self.params[0])
-    #    return numpy.array([[numpy.exp(-1j * lam / 2), 0],
-    #                        [0, numpy.exp(1j * lam / 2)]], dtype=complex)
+    def to_matrix(self):
+        """Return a numpy.array for the RZ gate."""
+        import numpy as np
+        ilam2 = 0.5j * float(self.params[0])
+        return np.array([[np.exp(-ilam2), 0],
+                         [0, np.exp(ilam2)]], dtype=complex)
 
 
 class CRZMeta(type):
@@ -214,13 +211,21 @@ def inverse(self):
     # 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 CRZ gate."""
-    #    arg = 1j * self.params[0] / 2
-    #    return numpy.array([[1,               0, 0,              0],
-    #                        [0, numpy.exp(-arg), 0,              0],
-    #                        [0,               0, 1,              0],
-    #                        [0,               0, 0, numpy.exp(arg)]],
-    #                       dtype=complex)
+    #   """Return a numpy.array for the CRZ gate."""
+    #   import numpy
+    #   arg = 1j * self.params[0] / 2
+    #   if self.ctrl_state:
+    #       return numpy.array([[1,               0, 0,              0],
+    #                           [0, numpy.exp(-arg), 0,              0],
+    #                           [0,               0, 1,              0],
+    #                           [0,               0, 0, numpy.exp(arg)]],
+    #                          dtype=complex)
+    #   else:
+    #       return numpy.array([[numpy.exp(-arg), 0,              0, 0],
+    #                           [              0, 1,              0, 0],
+    #                           [              0, 0, numpy.exp(arg), 0],
+    #                           [              0, 0,              0, 1]],
+    #                          dtype=complex)
 
 
 class CrzGate(CRZGate, metaclass=CRZMeta):

qiskit/circuit/library/standard_gates/rzx.py

@@ -16,7 +16,6 @@
 
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.quantumregister import QuantumRegister
-from .rz import RZGate
 from .h import HGate
 from .x import CXGate
 
@@ -125,11 +124,13 @@ def _define(self):
         """
         gate rzx(theta) a, b { h b; cx a, b; u1(theta) b; cx a, b; h b;}
         """
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.library.standard_gates import U1Gate
         q = QuantumRegister(2, 'q')
         self.definition = [
             (HGate(), [q[1]], []),
             (CXGate(), [q[0], q[1]], []),
-            (RZGate(self.params[0]), [q[1]], []),
+            (U1Gate(self.params[0]), [q[1]], []),  # Should be RZGate
             (CXGate(), [q[0], q[1]], []),
             (HGate(), [q[1]], [])
         ]
@@ -147,6 +148,7 @@ def inverse(self):
     #    isin = 1j * numpy.sin(half_theta)
     #    return numpy.array([[    cos,      0,   -isin,      0],
     #                        [      0,    cos,       0,   isin],
-    #                        [-1j*sin,      0,     cos,      0],
+    #                        [-isin,      0,     cos,      0],
     #                        [      0,   isin,       0,    cos]],
+    #                     [0, 1j*halfsin, 0, halfcos]],
     #                       dtype=complex)

qiskit/circuit/library/standard_gates/u1.py

@@ -219,16 +219,22 @@ def inverse(self):
         r"""Return inverted CU1 gate (:math:`CU1(\lambda){\dagger} = CU1(-\lambda)`)"""
         return CU1Gate(-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 CU1 gate."""
-    #    eith = numpy.exp(1j * self.params[0])
-    #    return numpy.array([[1, 0, 0,    0],
-    #                        [0, 1, 0,    0],
-    #                        [0, 0, 1,    0],
-    #                        [0, 0, 0, eith]],
-    #                       dtype=complex)
+    def to_matrix(self):
+        """Return a numpy.array for the CU1 gate."""
+
+        eith = numpy.exp(1j * float(self.params[0]))
+        if self.ctrl_state:
+            return numpy.array([[1, 0, 0, 0],
+                                [0, 1, 0, 0],
+                                [0, 0, 1, 0],
+                                [0, 0, 0, eith]],
+                               dtype=complex)
+        else:
+            return numpy.array([[1, 0, 0, 0],
+                                [0, 1, 0, 0],
+                                [0, 0, eith, 0],
+                                [0, 0, 0, 1]],
+                               dtype=complex)
 
 
 class Cu1Gate(CU1Gate, metaclass=CU1Meta):

qiskit/circuit/library/standard_gates/u3.py

@@ -93,15 +93,11 @@ def to_matrix(self):
         """Return a Numpy.array for the U3 gate."""
         theta, phi, lam = self.params
         theta, phi, lam = float(theta), float(phi), float(lam)
+        cos = numpy.cos(theta / 2)
+        sin = numpy.sin(theta / 2)
         return numpy.array([
-            [
-                numpy.cos(theta / 2),
-                -numpy.exp(1j * lam) * numpy.sin(theta / 2)
-            ],
-            [
-                numpy.exp(1j * phi) * numpy.sin(theta / 2),
-                numpy.exp(1j * (phi + lam)) * numpy.cos(theta / 2)
-            ]
+            [cos, -numpy.exp(1j * lam) * sin],
+            [numpy.exp(1j * phi) * sin, numpy.exp(1j * (phi + lam)) * cos]
         ], dtype=complex)
 
 

qiskit/circuit/quantumcircuit.py

@@ -77,6 +77,7 @@ class QuantumCircuit:
 
         name (str): the name of the quantum circuit. If not set, an
             automatically generated string will be assigned.
+        phase (float): The global phase of the circuit.
 
     Raises:
         CircuitError: if the circuit name, if given, is not valid.
@@ -134,7 +135,7 @@ class QuantumCircuit:
     header = "OPENQASM 2.0;"
     extension_lib = "include \"qelib1.inc\";"
 
-    def __init__(self, *regs, name=None):
+    def __init__(self, *regs, name=None, phase=0):
         if any([not isinstance(reg, (QuantumRegister, ClassicalRegister)) for reg in regs]):
             try:
                 regs = tuple(int(reg) for reg in regs)
@@ -167,6 +168,8 @@ def __init__(self, *regs, name=None):
         self._parameter_table = ParameterTable()
 
         self._layout = None
+        self._phase = 0
+        self.phase = phase
 
     @property
     def data(self):
@@ -271,7 +274,7 @@ def inverse(self):
             CircuitError: if the circuit cannot be inverted.
         """
         inverse_circ = QuantumCircuit(*self.qregs, *self.cregs,
-                                      name=self.name + '_dg')
+                                      name=self.name + '_dg', phase=-self.phase)
 
         for inst, qargs, cargs in reversed(self._data):
             inverse_circ._append(inst.inverse(), qargs, cargs)
@@ -287,7 +290,8 @@ def repeat(self, reps):
             QuantumCircuit: A circuit containing ``reps`` repetitions of this circuit.
         """
         repeated_circ = QuantumCircuit(*self.qregs, *self.cregs,
-                                       name=self.name + '**{}'.format(reps))
+                                       name=self.name + '**{}'.format(reps),
+                                       phase=reps * self.phase)
 
         # benefit of appending instructions: decomposing shows the subparts, i.e. the power
         # is actually `reps` times this circuit, and it is currently much faster than `compose`.
@@ -545,14 +549,15 @@ def cbit_argument_conversion(self, clbit_representation):
         """
         return QuantumCircuit._bit_argument_conversion(clbit_representation, self.clbits)
 
-    def append(self, instruction, qargs=None, cargs=None):
+    def append(self, instruction, qargs=None, cargs=None, phase=0):
         """Append one or more instructions to the end of the circuit, modifying
         the circuit in place. Expands qargs and cargs.
 
         Args:
             instruction (qiskit.circuit.Instruction): Instruction instance to append
             qargs (list(argument)): qubits to attach instruction to
             cargs (list(argument)): clbits to attach instruction to
+            phase (float): The global phase in radians of instruction.
 
         Returns:
             qiskit.circuit.Instruction: a handle to the instruction that was just added
@@ -578,6 +583,7 @@ def append(self, instruction, qargs=None, cargs=None):
         instructions = InstructionSet()
         for (qarg, carg) in instruction.broadcast_arguments(expanded_qargs, expanded_cargs):
             instructions.add(self._append(instruction, qarg, carg), qarg, carg)
+        self.phase += phase
         return instructions
 
     def _append(self, instruction, qargs, cargs):
@@ -1420,6 +1426,30 @@ def from_qasm_str(qasm_str):
         qasm = Qasm(data=qasm_str)
         return _circuit_from_qasm(qasm)
 
+    @property
+    def phase(self):
+        """Return the phase of the circuit."""
+        return self._phase
+
+    @phase.setter
+    def phase(self, angle):
+        """Set the phase of the circuit.
+
+        Args:
+            angle (float, ParameterExpression)
+        """
+        if isinstance(angle, ParameterExpression):
+            self._phase = angle
+        else:
+            # Set the phase to the [-2 * pi, 2 * pi] interval
+            angle = float(angle)
+            if not angle:
+                self._phase = 0
+            elif angle < 0:
+                self._phase = angle % (-2 * np.pi)
+            else:
+                self._phase = angle % (2 * np.pi)
+
     @property
     def parameters(self):
         """Convenience function to get the parameters defined in the parameter table."""
@@ -1559,6 +1589,9 @@ def _bind_parameter(self, parameter, value):
             # instructions), search the definition for instances of the
             # parameter which also need to be bound.
             self._rebind_definition(instr, parameter, value)
+        # bind circuit's phase
+        if isinstance(self.phase, ParameterExpression):
+            self.phase = self.phase.bind({parameter: value})
 
     def _substitute_parameter(self, old_parameter, new_parameter_expr):
         """Substitute an existing parameter in all circuit instructions and the parameter table."""
@@ -1570,6 +1603,8 @@ def _substitute_parameter(self, old_parameter, new_parameter_expr):
         entry = self._parameter_table.pop(old_parameter)
         for new_parameter in new_parameter_expr.parameters:
             self._parameter_table[new_parameter] = entry
+        if isinstance(self.phase, ParameterExpression):
+            self.phase = self.phase.subs({old_parameter: new_parameter_expr})
 
     def _rebind_definition(self, instruction, parameter, value):
         if instruction._definition:

qiskit/converters/circuit_to_dag.py

@@ -47,6 +47,7 @@ def circuit_to_dag(circuit):
     """
     dagcircuit = DAGCircuit()
     dagcircuit.name = circuit.name
+    dagcircuit.phase = circuit.phase
     for register in circuit.qregs:
         dagcircuit.add_qreg(register)
     for register in circuit.cregs:
@@ -55,4 +56,5 @@ def circuit_to_dag(circuit):
     for instruction, qargs, cargs in circuit.data:
         dagcircuit.apply_operation_back(instruction.copy(), qargs, cargs,
                                         instruction.condition)
+
     return dagcircuit

qiskit/converters/dag_to_circuit.py

@@ -48,7 +48,8 @@ def dag_to_circuit(dag):
     """
 
     name = dag.name or None
-    circuit = QuantumCircuit(*dag.qregs.values(), *dag.cregs.values(), name=name)
+    circuit = QuantumCircuit(*dag.qregs.values(), *dag.cregs.values(), name=name,
+                             phase=dag.phase)
 
     for node in dag.topological_op_nodes():
         # Get arguments for classical control (if any)