Deprecate QuantumCircuit.u1/2/3

azure-pipelines.yml

@@ -3,6 +3,9 @@
 # Add steps that analyze code, save the dist with the build record, publish to a PyPI-compatible index, and more:
 # https://docs.microsoft.com/azure/devops/pipelines/languages/python
 
+# TODO in L591 change git+https://github.com/Qiskit/qiskit-aqua back to "qiskit-aqua"
+# after the joint release of Terra 0.16 and Aqua 0.8
+
 trigger:
   branches:
     include:
@@ -585,7 +588,7 @@ stages:
             python -m pip install --upgrade pip
             pip install -U -r requirements.txt -r requirements-dev.txt -c constraints.txt
             pip install -c constraints.txt -e .
-            pip install "qiskit-ibmq-provider" "qiskit-aer" "z3-solver" "qiskit-ignis" "qiskit-aqua" "pyscf<1.7.4" "matplotlib<3.3.0" sphinx nbsphinx sphinx_rtd_theme cvxpy -c constraints.txt
+            pip install "qiskit-ibmq-provider" "qiskit-aer" "z3-solver" "qiskit-ignis" git+https://github.com/Qiskit/qiskit-aqua "pyscf<1.7.4" "matplotlib<3.3.0" sphinx nbsphinx sphinx_rtd_theme cvxpy -c constraints.txt
             python setup.py build_ext --inplace
             sudo apt install -y graphviz pandoc
             pip check

examples/python/ibmq/qft.py

@@ -27,14 +27,14 @@ def input_state(circ, n):
     """n-qubit input state for QFT that produces output 1."""
     for j in range(n):
         circ.h(j)
-        circ.u1(-math.pi/float(2**(j)), j)
+        circ.p(-math.pi/float(2**(j)), j)
 
 
 def qft(circ, n):
     """n-qubit QFT on q in circ."""
     for j in range(n):
         for k in range(j):
-            circ.cu1(math.pi/float(2**(j-k)), j, k)
+            circ.cp(math.pi/float(2**(j-k)), j, k)
         circ.h(j)
 
 

examples/python/qft.py

@@ -26,15 +26,17 @@ def input_state(circ, n):
     """n-qubit input state for QFT that produces output 1."""
     for j in range(n):
         circ.h(j)
-        circ.u1(-math.pi/float(2**(j)), j)
+        circ.p(-math.pi/float(2**(j)), j)
+
 
 def qft(circ, n):
     """n-qubit QFT on q in circ."""
     for j in range(n):
         for k in range(j):
-            circ.cu1(math.pi/float(2**(j-k)), j, k)
+            circ.cp(math.pi/float(2**(j-k)), j, k)
         circ.h(j)
 
+
 qft3 = QuantumCircuit(5, 5, name="qft3")
 qft4 = QuantumCircuit(5, 5, name="qft4")
 qft5 = QuantumCircuit(5, 5, name="qft5")

examples/python/teleport.py

@@ -37,7 +37,7 @@
 qc = QuantumCircuit(q, c0, c1, c2, name="teleport")
 
 # Prepare an initial state
-qc.u3(0.3, 0.2, 0.1, q[0])
+qc.u(0.3, 0.2, 0.1, q[0])
 
 # Prepare a Bell pair
 qc.h(q[1])

qiskit/circuit/add_control.py

@@ -111,7 +111,7 @@ def control(operation: Union[Gate, ControlledGate],
         if operation.definition is not None and operation.definition.global_phase:
             global_phase += operation.definition.global_phase
     else:
-        basis = ['u1', 'u3', 'x', 'rx', 'ry', 'rz', 'cx']
+        basis = ['p', 'u', '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':
@@ -130,13 +130,15 @@ def control(operation: Union[Gate, ControlledGate],
                 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 == 'p':
+                from qiskit.circuit.library import MCPhaseGate
+                controlled_circ.append(MCPhaseGate(gate.params[0], num_ctrl_qubits),
+                                       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':
+            elif gate.name == 'u':
                 theta, phi, lamb = gate.params
                 if phi == -pi / 2 and lamb == pi / 2:
                     controlled_circ.mcrx(theta, q_control, q_target[qreg[0].index],
@@ -162,10 +164,10 @@ def control(operation: Union[Gate, ControlledGate],
     # 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)
+            controlled_circ.p(operation.definition.global_phase + global_phase, q_control)
         else:
-            controlled_circ.mcu1(operation.definition.global_phase + global_phase,
-                                 q_control[:-1], q_control[-1])
+            controlled_circ.mcp(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

qiskit/circuit/library/arithmetic/quadratic_form.py

@@ -132,7 +132,7 @@ def __init__(self,
         # constant coefficient
         if offset != 0:
             for i, q_i in enumerate(qr_result):
-                self.u1(scaling * 2 ** i * offset, q_i)
+                self.p(scaling * 2 ** i * offset, q_i)
 
         # the linear part consists of the vector and the diagonal of the
         # matrix, since x_i * x_i = x_i, as x_i is a binary variable
@@ -141,7 +141,7 @@ def __init__(self,
             value += quadratic[j][j] if quadratic is not None else 0
             if value != 0:
                 for i, q_i in enumerate(qr_result):
-                    self.cu1(scaling * 2 ** i * value, qr_input[j], q_i)
+                    self.cp(scaling * 2 ** i * value, qr_input[j], q_i)
 
         # the quadratic part adds A_ij and A_ji as x_i x_j == x_j x_i
         if quadratic is not None:
@@ -150,7 +150,7 @@ def __init__(self,
                     value = quadratic[j][k] + quadratic[k][j]
                     if value != 0:
                         for i, q_i in enumerate(qr_result):
-                            self.mcu1(scaling * 2 ** i * value, [qr_input[j], qr_input[k]], q_i)
+                            self.mcp(scaling * 2 ** i * value, [qr_input[j], qr_input[k]], q_i)
 
         # add the inverse QFT
         iqft = QFT(num_result_qubits, do_swaps=False).inverse()

qiskit/circuit/library/basis_change/qft.py

@@ -257,7 +257,7 @@ def _build(self) -> None:
             num_entanglements = max(0, self.num_qubits - max(self.approximation_degree, j))
             for k in range(j + 1, j + num_entanglements):
                 lam = np.pi / (2 ** (k - j))
-                self.cu1(lam, j, k)
+                self.cp(lam, j, k)
 
             if self.insert_barriers:
                 self.barrier()

qiskit/circuit/library/data_preparation/pauli_feature_map.py

@@ -240,7 +240,7 @@ def cx_chain(circuit, inverse=False):
 
         basis_change(evo)
         cx_chain(evo)
-        evo.u1(2.0 * time, indices[-1])
+        evo.p(2.0 * time, indices[-1])
         cx_chain(evo, inverse=True)
         basis_change(evo, inverse=True)
         return evo

qiskit/circuit/library/iqp.py

@@ -88,11 +88,11 @@ def __init__(self, interactions: Union[List, np.array]) -> None:
         for i in range(num_qubits):
             for j in range(i+1, num_qubits):
                 if interactions[i][j] % 4 != 0:
-                    inner.cu1(interactions[i][j] * np.pi / 2, i, j)
+                    inner.cp(interactions[i][j] * np.pi / 2, i, j)
 
         for i in range(num_qubits):
             if interactions[i][i] % 8 != 0:
-                inner.u1(interactions[i][i] * np.pi / 8, i)
+                inner.p(interactions[i][i] * np.pi / 8, i)
 
         inner.h(range(num_qubits))
         all_qubits = self.qubits

qiskit/circuit/library/n_local/excitation_preserving.py

@@ -139,7 +139,7 @@ def __init__(self,
         swap.ryy(theta, 0, 1)
         if mode == 'fsim':
             phi = Parameter('φ')
-            swap.cu1(phi, 0, 1)
+            swap.cp(phi, 0, 1)
 
         super().__init__(num_qubits=num_qubits,
                          rotation_blocks=RZGate,

qiskit/circuit/library/standard_gates/equivalence_library.py

@@ -112,9 +112,15 @@
 q = QuantumRegister(1, 'q')
 theta = Parameter('theta')
 phase_to_u1 = QuantumCircuit(q)
-phase_to_u1.u1(theta, 0)
+phase_to_u1.append(U1Gate(theta), [0])
 _sel.add_equivalence(PhaseGate(theta), phase_to_u1)
 
+q = QuantumRegister(1, 'q')
+theta = Parameter('theta')
+phase_to_u = QuantumCircuit(q)
+phase_to_u.u(0, 0, theta, 0)
+_sel.add_equivalence(PhaseGate(theta), phase_to_u)
+
 # CPhaseGate
 
 q = QuantumRegister(2, 'q')
@@ -130,7 +136,7 @@
 q = QuantumRegister(2, 'q')
 theta = Parameter('theta')
 cphase_to_cu1 = QuantumCircuit(q)
-cphase_to_cu1.cu1(theta, 0, 1)
+cphase_to_cu1.append(CU1Gate(theta), [0, 1])
 _sel.add_equivalence(CPhaseGate(theta), cphase_to_cu1)
 
 # RGate
@@ -440,7 +446,7 @@
 phi = Parameter('phi')
 lam = Parameter('lam')
 u_to_u3 = QuantumCircuit(q)
-u_to_u3.u3(theta, phi, lam, 0)
+u_to_u3.append(U3Gate(theta, phi, lam), [0])
 _sel.add_equivalence(UGate(theta, phi, lam), u_to_u3)
 
 # CUGate
@@ -467,7 +473,7 @@
 gamma = Parameter('gamma')
 cu_to_cu3 = QuantumCircuit(q)
 cu_to_cu3.p(gamma, 0)
-cu_to_cu3.cu3(theta, phi, lam, 0, 1)
+cu_to_cu3.append(CU3Gate(theta, phi, lam), [0, 1])
 _sel.add_equivalence(CUGate(theta, phi, lam, gamma), cu_to_cu3)
 
 # U1Gate
@@ -514,9 +520,9 @@
 phi = Parameter('phi')
 lam = Parameter('lam')
 u2_to_u1sx = QuantumCircuit(q, global_phase=-pi / 4)
-u2_to_u1sx.u1(lam - pi/2, 0)
+u2_to_u1sx.append(U1Gate(lam - pi/2), [0])
 u2_to_u1sx.sx(0)
-u2_to_u1sx.u1(phi + pi/2, 0)
+u2_to_u1sx.append(U1Gate(phi + pi/2), [0])
 _sel.add_equivalence(U2Gate(phi, lam), u2_to_u1sx)
 
 # U3Gate

qiskit/circuit/library/standard_gates/multi_control_rotation_gates.py

@@ -23,20 +23,21 @@
 logger = logging.getLogger(__name__)
 
 
-def _apply_cu3(circuit, theta, phi, lam, control, target, use_basis_gates=True):
+def _apply_cu(circuit, theta, phi, lam, control, target, use_basis_gates=True):
     if use_basis_gates:
-        circuit.u1((lam + phi) / 2, control)
-        circuit.u1((lam - phi) / 2, target)
+        # pylint: disable=cyclic-import
+        circuit.p((lam + phi) / 2, [control])
+        circuit.p((lam - phi) / 2, [target])
         circuit.cx(control, target)
-        circuit.u3(-theta / 2, 0, -(phi + lam) / 2, target)
+        circuit.u(-theta / 2, 0, -(phi + lam) / 2, [target])
         circuit.cx(control, target)
-        circuit.u3(theta / 2, phi, 0, target)
+        circuit.u(theta / 2, phi, 0, [target])
     else:
         circuit.cu(theta, phi, lam, 0, control, target)
 
 
-def _apply_mcu3_graycode(circuit, theta, phi, lam, ctls, tgt, use_basis_gates):
-    """Apply multi-controlled u3 gate from ctls to tgt using graycode
+def _apply_mcu_graycode(circuit, theta, phi, lam, ctls, tgt, use_basis_gates):
+    """Apply multi-controlled u gate from ctls to tgt using graycode
     pattern with single-step angles theta, phi, lam."""
 
     n = len(ctls)
@@ -67,12 +68,12 @@ def _apply_mcu3_graycode(circuit, theta, phi, lam, ctls, tgt, use_basis_gates):
                     circuit.cx(ctls[idx], ctls[lm_pos])
         # check parity and undo rotation
         if pattern.count('1') % 2 == 0:
-            # inverse CU3: u3(theta, phi, lamb)^dagger = u3(-theta, -lam, -phi)
-            _apply_cu3(circuit, -theta, -lam, -phi, ctls[lm_pos], tgt,
-                       use_basis_gates=use_basis_gates)
+            # inverse CU: u(theta, phi, lamb)^dagger = u(-theta, -lam, -phi)
+            _apply_cu(circuit, -theta, -lam, -phi, ctls[lm_pos], tgt,
+                      use_basis_gates=use_basis_gates)
         else:
-            _apply_cu3(circuit, theta, phi, lam, ctls[lm_pos], tgt,
-                       use_basis_gates=use_basis_gates)
+            _apply_cu(circuit, theta, phi, lam, ctls[lm_pos], tgt,
+                      use_basis_gates=use_basis_gates)
         last_pattern = pattern
 
 
@@ -85,7 +86,7 @@ def mcrx(self, theta, q_controls, q_target, use_basis_gates=False):
         theta (float): angle theta
         q_controls (list(Qubit)): The list of control qubits
         q_target (Qubit): The target qubit
-        use_basis_gates (bool): use u1, u2, u3, cx, id
+        use_basis_gates (bool): use p, u, cx
 
     Raises:
         QiskitError: parameter errors
@@ -112,13 +113,13 @@ def mcrx(self, theta, q_controls, q_target, use_basis_gates=False):
     self._check_dups(all_qubits)
 
     n_c = len(control_qubits)
-    if n_c == 1:  # cu3
-        _apply_cu3(self, theta, -pi/2, pi/2, control_qubits[0],
-                   target_qubit, use_basis_gates=use_basis_gates)
+    if n_c == 1:  # cu
+        _apply_cu(self, theta, -pi/2, pi/2, control_qubits[0],
+                  target_qubit, use_basis_gates=use_basis_gates)
     else:
         theta_step = theta * (1 / (2 ** (n_c - 1)))
-        _apply_mcu3_graycode(self, theta_step, -pi/2, pi/2, control_qubits,
-                             target_qubit, use_basis_gates=use_basis_gates)
+        _apply_mcu_graycode(self, theta_step, -pi/2, pi/2, control_qubits,
+                            target_qubit, use_basis_gates=use_basis_gates)
 
 
 def mcry(self, theta, q_controls, q_target, q_ancillae, mode=None,
@@ -133,7 +134,7 @@ def mcry(self, theta, q_controls, q_target, q_ancillae, mode=None,
         q_target (Qubit): The target qubit
         q_ancillae (QuantumRegister or tuple(QuantumRegister, int)): The list of ancillary qubits.
         mode (string): The implementation mode to use
-        use_basis_gates (bool): use u1, u2, u3, cx, id
+        use_basis_gates (bool): use p, u, cx
 
     Raises:
         QiskitError: parameter errors
@@ -186,13 +187,13 @@ def mcry(self, theta, q_controls, q_target, q_ancillae, mode=None,
         self.mcx(q_controls, q_target, q_ancillae, mode='v-chain')
     elif mode == 'noancilla':
         n_c = len(control_qubits)
-        if n_c == 1:  # cu3
-            _apply_cu3(self, theta, 0, 0, control_qubits[0],
-                       target_qubit, use_basis_gates=use_basis_gates)
+        if n_c == 1:  # cu
+            _apply_cu(self, theta, 0, 0, control_qubits[0],
+                      target_qubit, use_basis_gates=use_basis_gates)
         else:
             theta_step = theta * (1 / (2 ** (n_c - 1)))
-            _apply_mcu3_graycode(self, theta_step, 0, 0, control_qubits,
-                                 target_qubit, use_basis_gates=use_basis_gates)
+            _apply_mcu_graycode(self, theta_step, 0, 0, control_qubits,
+                                target_qubit, use_basis_gates=use_basis_gates)
     else:
         raise QiskitError('Unrecognized mode for building MCRY circuit: {}.'.format(mode))
 
@@ -206,7 +207,7 @@ def mcrz(self, lam, q_controls, q_target, use_basis_gates=False):
         lam (float): angle lambda
         q_controls (list(Qubit)): The list of control qubits
         q_target (Qubit): The target qubit
-        use_basis_gates (bool): use u1, u2, u3, cx, id
+        use_basis_gates (bool): use p, u, cx
 
     Raises:
         QiskitError: parameter errors
@@ -233,13 +234,13 @@ def mcrz(self, lam, q_controls, q_target, use_basis_gates=False):
     self._check_dups(all_qubits)
 
     n_c = len(control_qubits)
-    if n_c == 1:  # cu3
-        _apply_cu3(self, 0, 0, lam, control_qubits[0],
-                   target_qubit, use_basis_gates=use_basis_gates)
+    if n_c == 1:  # cu
+        _apply_cu(self, 0, 0, lam, control_qubits[0],
+                  target_qubit, use_basis_gates=use_basis_gates)
     else:
         lam_step = lam * (1 / (2 ** (n_c - 1)))
-        _apply_mcu3_graycode(self, 0, 0, lam_step, control_qubits,
-                             target_qubit, use_basis_gates=use_basis_gates)
+        _apply_mcu_graycode(self, 0, 0, lam_step, control_qubits,
+                            target_qubit, use_basis_gates=use_basis_gates)
 
 
 QuantumCircuit.mcrx = mcrx

qiskit/circuit/library/standard_gates/p.py

@@ -76,9 +76,10 @@ def __init__(self, theta, label=None):
     def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from .u import UGate
         q = QuantumRegister(1, 'q')
         qc = QuantumCircuit(q, name=self.name)
-        qc.u1(self.params[0], 0)
+        qc.append(UGate(0, 0, self.params[0]), [0])
         self.definition = qc
 
     def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None):

qiskit/circuit/library/standard_gates/u.py

@@ -89,14 +89,6 @@ def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None):
             return gate
         return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label, ctrl_state=ctrl_state)
 
-    def _define(self):
-        """Alias for U3 until U becomes a basis gate."""
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
-        q = QuantumRegister(1, 'q')
-        qc = QuantumCircuit(q)
-        qc.u3(self.params[0], self.params[1], self.params[2], q[0])
-        self.definition = qc
-
     def to_matrix(self):
         """Return a numpy.array for the U gate."""
         theta, phi, lam = [float(param) for param in self.params]