Consistent naming of the standard gates

qiskit/assembler/disassemble.py

@@ -50,8 +50,6 @@ def _experiments_to_circuits(qobj):
             conditional = {}
             for i in x.instructions:
                 name = i.name
-                if i.name == 'id':
-                    name = 'iden'
                 qubits = []
                 params = getattr(i, 'params', [])
                 try:

qiskit/circuit/add_control.py

@@ -54,7 +54,7 @@ def add_control(operation: Union[Gate, ControlledGate],
         # the condition matching 'name' above is to catch a test case,
         # 'TestControlledGate.test_rotation_gates', where the rz gate
         # gets converted to a circuit before becoming a generic Gate object.
-        cgate = standard.CrzGate(*operation.params)
+        cgate = standard.CRZGate(*operation.params)
         return cgate.control(num_ctrl_qubits - 1)
     if isinstance(operation, UnitaryGate):
         # attempt decomposition
@@ -119,7 +119,7 @@ def control(operation: Union[Gate, ControlledGate],
         for rule in bgate.definition:
             if rule[0].name == 'u3':
                 theta, phi, lamb = rule[0].params
-                if phi == -pi/2 and lamb == pi/2:
+                if phi == -pi / 2 and lamb == pi / 2:
                     qc.mcrx(theta, q_control, q_target[rule[1][0].index],
                             use_basis_gates=True)
                 elif phi == 0 and lamb == 0:

qiskit/circuit/random/utils.py

@@ -18,12 +18,12 @@
 
 from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
 from qiskit.circuit import Reset
-from qiskit.extensions import (IdGate, U1Gate, U2Gate, U3Gate, XGate,
+from qiskit.extensions import (IGate, U1Gate, U2Gate, U3Gate, XGate,
                                YGate, ZGate, HGate, SGate, SdgGate, TGate,
-                               TdgGate, RXGate, RYGate, RZGate, CnotGate,
-                               CyGate, CzGate, CHGate, CrzGate, Cu1Gate,
-                               Cu3Gate, SwapGate, RZZGate,
-                               ToffoliGate, FredkinGate)
+                               TdgGate, RXGate, RYGate, RZGate, CXGate,
+                               CYGate, CZGate, CHGate, CRZGate, CU1Gate,
+                               CU3Gate, SwapGate, RZZGate,
+                               CCXGate, CSwapGate)
 from qiskit.circuit.exceptions import CircuitError
 
 
@@ -49,14 +49,14 @@ def random_circuit(n_qubits, depth, max_operands=3, measure=False,
     if max_operands < 1 or max_operands > 3:
         raise CircuitError("max_operands must be between 1 and 3")
 
-    one_q_ops = [IdGate, U1Gate, U2Gate, U3Gate, XGate, YGate, ZGate,
+    one_q_ops = [IGate, U1Gate, U2Gate, U3Gate, XGate, YGate, ZGate,
                  HGate, SGate, SdgGate, TGate, TdgGate, RXGate, RYGate, RZGate]
-    one_param = [U1Gate, RXGate, RYGate, RZGate, RZZGate, Cu1Gate, CrzGate]
+    one_param = [U1Gate, RXGate, RYGate, RZGate, RZZGate, CU1Gate, CRZGate]
     two_param = [U2Gate]
-    three_param = [U3Gate, Cu3Gate]
-    two_q_ops = [CnotGate, CyGate, CzGate, CHGate, CrzGate,
-                 Cu1Gate, Cu3Gate, SwapGate, RZZGate]
-    three_q_ops = [ToffoliGate, FredkinGate]
+    three_param = [U3Gate, CU3Gate]
+    two_q_ops = [CXGate, CYGate, CZGate, CHGate, CRZGate,
+                 CU1Gate, CU3Gate, SwapGate, RZZGate]
+    three_q_ops = [CCXGate, CSwapGate]
 
     qr = QuantumRegister(n_qubits, 'q')
     qc = QuantumCircuit(n_qubits)
@@ -96,7 +96,7 @@ def random_circuit(n_qubits, depth, max_operands=3, measure=False,
                 num_angles = 3
             else:
                 num_angles = 0
-            angles = [rng.uniform(0, 2*np.pi) for x in range(num_angles)]
+            angles = [rng.uniform(0, 2 * np.pi) for x in range(num_angles)]
             register_operands = [qr[i] for i in operands]
             op = operation(*angles)
 

qiskit/converters/ast_to_dag.py

@@ -25,14 +25,14 @@
 from qiskit.circuit.measure import Measure
 from qiskit.circuit.reset import Reset
 from qiskit.extensions.standard.barrier import Barrier
-from qiskit.extensions.standard.x import ToffoliGate
-from qiskit.extensions.standard.swap import FredkinGate
-from qiskit.extensions.standard.x import CnotGate
-from qiskit.extensions.standard.y import CyGate
-from qiskit.extensions.standard.z import CzGate
+from qiskit.extensions.standard.x import CCXGate
+from qiskit.extensions.standard.swap import CSwapGate
+from qiskit.extensions.standard.x import CXGate
+from qiskit.extensions.standard.y import CYGate
+from qiskit.extensions.standard.z import CZGate
 from qiskit.extensions.standard.swap import SwapGate
 from qiskit.extensions.standard.h import HGate
-from qiskit.extensions.standard.iden import IdGate
+from qiskit.extensions.standard.i import IGate
 from qiskit.extensions.standard.s import SGate
 from qiskit.extensions.standard.s import SdgGate
 from qiskit.extensions.standard.t import TGate
@@ -46,14 +46,14 @@
 from qiskit.extensions.standard.rx import RXGate
 from qiskit.extensions.standard.ry import RYGate
 from qiskit.extensions.standard.rz import RZGate
-from qiskit.extensions.standard.u1 import Cu1Gate
-from qiskit.extensions.standard.h import CHGate
-from qiskit.extensions.standard.rx import CrxGate
-from qiskit.extensions.standard.ry import CryGate
-from qiskit.extensions.standard.rz import CrzGate
-from qiskit.extensions.standard.u3 import Cu3Gate
 from qiskit.extensions.standard.rxx import RXXGate
 from qiskit.extensions.standard.rzz import RZZGate
+from qiskit.extensions.standard.u1 import CU1Gate
+from qiskit.extensions.standard.u3 import CU3Gate
+from qiskit.extensions.standard.h import CHGate
+from qiskit.extensions.standard.rx import CRXGate
+from qiskit.extensions.standard.ry import CRYGate
+from qiskit.extensions.standard.rz import CRZGate
 
 
 def ast_to_dag(ast):
@@ -113,19 +113,19 @@ class AstInterpreter:
                           "ry": RYGate,
                           "rz": RZGate,
                           "rzz": RZZGate,
-                          "id": IdGate,
+                          "id": IGate,
                           "h": HGate,
-                          "cx": CnotGate,
-                          "cy": CyGate,
-                          "cz": CzGate,
+                          "cx": CXGate,
+                          "cy": CYGate,
+                          "cz": CZGate,
                           "ch": CHGate,
-                          "crx": CrxGate,
-                          "cry": CryGate,
-                          "crz": CrzGate,
-                          "cu1": Cu1Gate,
-                          "cu3": Cu3Gate,
-                          "ccx": ToffoliGate,
-                          "cswap": FredkinGate}
+                          "crx": CRXGate,
+                          "cry": CRYGate,
+                          "crz": CRZGate,
+                          "cu1": CU1Gate,
+                          "cu3": CU3Gate,
+                          "ccx": CCXGate,
+                          "cswap": CSwapGate}
 
     def __init__(self, dag):
         """Initialize interpreter's data."""
@@ -239,11 +239,11 @@ def _process_cnot(self, node):
         maxidx = max([len(id0), len(id1)])
         for idx in range(maxidx):
             if len(id0) > 1 and len(id1) > 1:
-                self.dag.apply_operation_back(CnotGate(), [id0[idx], id1[idx]], [], self.condition)
+                self.dag.apply_operation_back(CXGate(), [id0[idx], id1[idx]], [], self.condition)
             elif len(id0) > 1:
-                self.dag.apply_operation_back(CnotGate(), [id0[idx], id1[0]], [], self.condition)
+                self.dag.apply_operation_back(CXGate(), [id0[idx], id1[0]], [], self.condition)
             else:
-                self.dag.apply_operation_back(CnotGate(), [id0[0], id1[idx]], [], self.condition)
+                self.dag.apply_operation_back(CXGate(), [id0[0], id1[idx]], [], self.condition)
 
     def _process_measure(self, node):
         """Process a measurement node."""

qiskit/converters/dag_to_circuit.py

@@ -31,7 +31,7 @@ def dag_to_circuit(dag):
             from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
             from qiskit.dagcircuit import DAGCircuit
             from qiskit.converters import circuit_to_dag
-            from qiskit.extensions.standard import CHGate, U2Gate, CnotGate
+            from qiskit.extensions.standard import CHGate, U2Gate, CXGate
             from qiskit.converters import dag_to_circuit
             %matplotlib inline
 

qiskit/extensions/__init__.py

@@ -26,19 +26,19 @@
    :toctree: ../stubs/
 
    Barrier
-   ToffoliGate
+   CCXGate
    CHGate
-   CrxGate
-   CryGate
-   CrzGate
-   FredkinGate
-   Cu1Gate
-   Cu3Gate
-   CnotGate
-   CyGate
-   CzGate
+   CRXGate
+   CRYGate
+   CRZGate
+   CSwapGate
+   CU1Gate
+   CU3Gate
+   CXGate
+   CYGate
+   CZGate
    HGate
-   IdGate
+   IGate
    MSGate
    RXGate
    RXXGate

qiskit/extensions/quantum_initializer/__init__.py

@@ -15,9 +15,9 @@
 """Initialize qubit registers to desired arbitrary state."""
 
 from .squ import SingleQubitUnitary
-from .ucz import UCZ
-from .ucy import UCY
-from .ucx import UCX
-from .diag import DiagGate
-from .ucg import UCG
+from .ucrz import UCRZGate
+from .ucry import UCRYGate
+from .ucrx import UCRXGate
+from .diagonal import DiagonalGate
+from .uc import UCGate
 from .isometry import Isometry

qiskit/extensions/quantum_initializer/diag.py

@@ -2,7 +2,7 @@
 
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2019.
+# (C) Copyright IBM 2020.
 #
 # This code is licensed under the Apache License, Version 2.0. You may
 # obtain a copy of this license in the LICENSE.txt file in the root directory
@@ -12,132 +12,14 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-# The structure of the code is based on Emanuel Malvetti's semester thesis at ETH in 2018,
-# which was supervised by Raban Iten and Prof. Renato Renner.
+"""The diagonal gate.
 
-# pylint: disable=missing-param-doc
-# pylint: disable=missing-type-doc
-
-"""
-Decomposes a diagonal matrix into elementary gates using the method described in Theorem 7 in
-"Synthesis of Quantum Logic Circuits" by Shende et al. (https://arxiv.org/pdf/quant-ph/0406176.pdf).
+This module is deprecated, see diagonal.py
 """
-import cmath
-import math
-
-import numpy as np
-
-from qiskit.circuit import Gate
-from qiskit.circuit.quantumcircuit import QuantumCircuit, QuantumRegister
-from qiskit.exceptions import QiskitError
-
-_EPS = 1e-10  # global variable used to chop very small numbers to zero
-
-
-class DiagGate(Gate):
-    """
-    diag =  list of the 2^k diagonal entries (for a diagonal gate on k qubits). Must contain at
-    least two entries.
-    """
-
-    def __init__(self, diag):
-        """Check types"""
-        # Check if diag has type "list"
-        if not isinstance(diag, list):
-            raise QiskitError("The diagonal entries are not provided in a list.")
-        # Check if the right number of diagonal entries is provided and if the diagonal entries
-        # have absolute value one.
-        num_action_qubits = math.log2(len(diag))
-        if num_action_qubits < 1 or not num_action_qubits.is_integer():
-            raise QiskitError("The number of diagonal entries is not a positive power of 2.")
-        for z in diag:
-            try:
-                complex(z)
-            except TypeError:
-                raise QiskitError("Not all of the diagonal entries can be converted to "
-                                  "complex numbers.")
-            if not np.abs(z) - 1 < _EPS:
-                raise QiskitError("A diagonal entry has not absolute value one.")
-        # Create new gate.
-        super().__init__("diag", int(num_action_qubits), diag)
-
-    def _define(self):
-        diag_circuit = self._dec_diag()
-        gate = diag_circuit.to_instruction()
-        q = QuantumRegister(self.num_qubits)
-        diag_circuit = QuantumCircuit(q)
-        diag_circuit.append(gate, q[:])
-        self.definition = diag_circuit.data
-
-    def _dec_diag(self):
-        """
-        Call to create a circuit implementing the diagonal gate.
-        """
-        q = QuantumRegister(self.num_qubits)
-        circuit = QuantumCircuit(q)
-        # Since the diagonal is a unitary, all its entries have absolute value one and the diagonal
-        # is fully specified by the phases of its entries
-        diag_phases = [cmath.phase(z) for z in self.params]
-        n = len(self.params)
-        while n >= 2:
-            angles_rz = []
-            for i in range(0, n, 2):
-                diag_phases[i // 2], rz_angle = _extract_rz(diag_phases[i], diag_phases[i + 1])
-                angles_rz.append(rz_angle)
-            num_act_qubits = int(np.log2(n))
-            contr_qubits = q[self.num_qubits - num_act_qubits + 1:self.num_qubits]
-            target_qubit = q[self.num_qubits - num_act_qubits]
-            circuit.ucz(angles_rz, contr_qubits, target_qubit)
-            n //= 2
-        return circuit
-
-
-# extract a Rz rotation (angle given by first output) such that exp(j*phase)*Rz(z_angle)
-# is equal to the diagonal matrix with entires exp(1j*ph1) and exp(1j*ph2)
-def _extract_rz(phi1, phi2):
-    phase = (phi1 + phi2) / 2.0
-    z_angle = phi2 - phi1
-    return phase, z_angle
-
-
-def diag_gate(self, diag, qubit):
-    """Attach a diagonal gate to a circuit.
-
-    The decomposition is based on Theorem 7 given in "Synthesis of Quantum Logic Circuits" by
-    Shende et al. (https://arxiv.org/pdf/quant-ph/0406176.pdf).
-
-    Args:
-        diag (list): list of the 2^k diagonal entries (for a diagonal gate on k qubits).
-            Must contain at least two entries
-        qubit (QuantumRegister|list): list of k qubits the diagonal is
-            acting on (the order of the qubits specifies the computational basis in which the
-            diagonal gate is provided: the first element in diag acts on the state where all
-            the qubits in q are in the state 0, the second entry acts on the state where all
-            the qubits q[1],...,q[k-1] are in the state zero and q[0] is in the state 1,
-            and so on)
-
-    Returns:
-        QuantumCircuit: the diagonal gate which was attached to the circuit.
-
-    Raises:
-        QiskitError: if the list of the diagonal entries or the qubit list is in bad format;
-            if the number of diagonal entries is not 2^k, where k denotes the number of qubits
-    """
-
-    if isinstance(qubit, QuantumRegister):
-        qubit = qubit[:]
-    # Check if q has type "list"
-    if not isinstance(qubit, list):
-        raise QiskitError("The qubits must be provided as a list "
-                          "(also if there is only one qubit).")
-    # Check if diag has type "list"
-    if not isinstance(diag, list):
-        raise QiskitError("The diagonal entries are not provided in a list.")
-    num_action_qubits = math.log2(len(diag))
-    if not len(qubit) == num_action_qubits:
-        raise QiskitError("The number of diagonal entries does not correspond to"
-                          " the number of qubits.")
-    return self.append(DiagGate(diag), qubit)
 
+import warnings
+# pylint: disable=unused-import
+from qiskit.extensions.quantum_initializer.diagonal import DiagGate, diag_gate
 
-QuantumCircuit.diag_gate = diag_gate
+warnings.warn('This module is deprecated. The DiagonalGate/DiagGate is now in diagonal.py',
+              category=DeprecationWarning, stacklevel=2)