diff --git a/qiskit/circuit/add_control.py b/qiskit/circuit/add_control.py
index 52668e6a0b42..cae4c74e3ea3 100644
--- a/qiskit/circuit/add_control.py
+++ b/qiskit/circuit/add_control.py
@@ -31,77 +31,20 @@ def add_control(operation, num_ctrl_qubits, label):
             uses num_ctrl_qubits-1 ancillae qubits so returns a gate of size
             num_qubits + 2*num_ctrl_qubits - 1.
     """
+    import qiskit.extensions.standard as standard
+    if isinstance(operation, standard.RZGate) or operation.name == 'rz':
+        # num_ctrl_qubits > 1
+        # 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)
+        return cgate.control(num_ctrl_qubits - 1)
     if isinstance(operation, UnitaryGate):
         # attempt decomposition
         operation._define()
-    if _control_definition_known(operation, num_ctrl_qubits):
-        return _control_predefined(operation, num_ctrl_qubits)
     return control(operation, num_ctrl_qubits=num_ctrl_qubits, label=label)
 
 
-def _control_definition_known(operation, num_ctrl_qubits):
-    if num_ctrl_qubits == 2 and operation.name == 'x':
-        return True
-    elif num_ctrl_qubits == 1:
-        return operation.name in {'x', 'y', 'z', 'h', 'rx', 'ry', 'rz', 'swap', 'u1', 'u3', 'cx'}
-    elif operation.name == 'rz' and num_ctrl_qubits > 1:
-        return True
-    else:
-        return False
-
-
-def _control_predefined(operation, num_ctrl_qubits):
-    """Returns controlled gates with hard-coded definitions in
-    the standard extensions."""
-    if operation.name == 'x' and num_ctrl_qubits in [1, 2]:
-        if num_ctrl_qubits == 1:
-            import qiskit.extensions.standard.cx
-            cgate = qiskit.extensions.standard.cx.CnotGate()
-        else:
-            import qiskit.extensions.standard.ccx
-            cgate = qiskit.extensions.standard.ccx.ToffoliGate()
-    elif operation.name == 'y':
-        import qiskit.extensions.standard.cy
-        cgate = qiskit.extensions.standard.cy.CyGate()
-    elif operation.name == 'z':
-        import qiskit.extensions.standard.cz
-        cgate = qiskit.extensions.standard.cz.CzGate()
-    elif operation.name == 'h':
-        import qiskit.extensions.standard.ch
-        cgate = qiskit.extensions.standard.ch.CHGate()
-    elif operation.name in {'rx', 'ry', 'rz'}:
-        if operation.name == 'rx':
-            import qiskit.extensions.standard.crx
-            cgate = qiskit.extensions.standard.crx.CrxGate(*operation.params)
-        elif operation.name == 'ry':
-            import qiskit.extensions.standard.cry
-            cgate = qiskit.extensions.standard.cry.CryGate(*operation.params)
-        else:  # operation.name == 'rz'
-            import qiskit.extensions.standard.crz
-            cgate = qiskit.extensions.standard.crz.CrzGate(*operation.params)
-        if num_ctrl_qubits == 1:
-            return cgate
-        else:
-            # only predefined for one control qubit
-            return cgate.control(num_ctrl_qubits - 1)
-    elif operation.name == 'swap':
-        import qiskit.extensions.standard.cswap
-        cgate = qiskit.extensions.standard.cswap.FredkinGate()
-    elif operation.name == 'u1':
-        import qiskit.extensions.standard.cu1
-        cgate = qiskit.extensions.standard.cu1.Cu1Gate(*operation.params)
-    elif operation.name == 'u3':
-        import qiskit.extensions.standard.cu3
-        cgate = qiskit.extensions.standard.cu3.Cu3Gate(*operation.params)
-    elif operation.name == 'cx':
-        import qiskit.extensions.standard.ccx
-        cgate = qiskit.extensions.standard.ccx.ToffoliGate()
-    else:
-        raise QiskitError('No standard controlled gate for "{}"'.format(
-            operation.name))
-    return cgate
-
-
 def control(operation, num_ctrl_qubits=1, label=None):
     """Return controlled version of gate using controlled rotations
 
diff --git a/qiskit/converters/ast_to_dag.py b/qiskit/converters/ast_to_dag.py
index 1f31e3cce026..3e07aec68f7c 100644
--- a/qiskit/converters/ast_to_dag.py
+++ b/qiskit/converters/ast_to_dag.py
@@ -25,11 +25,11 @@
 from qiskit.circuit.measure import Measure
 from qiskit.circuit.reset import Reset
 from qiskit.extensions.standard.barrier import Barrier
-from qiskit.extensions.standard.ccx import ToffoliGate
-from qiskit.extensions.standard.cswap import FredkinGate
-from qiskit.extensions.standard.cx import CnotGate
-from qiskit.extensions.standard.cy import CyGate
-from qiskit.extensions.standard.cz import CzGate
+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.swap import SwapGate
 from qiskit.extensions.standard.h import HGate
 from qiskit.extensions.standard.iden import IdGate
@@ -46,12 +46,12 @@
 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.cu1 import Cu1Gate
-from qiskit.extensions.standard.ch import CHGate
-from qiskit.extensions.standard.crx import CrxGate
-from qiskit.extensions.standard.cry import CryGate
-from qiskit.extensions.standard.crz import CrzGate
-from qiskit.extensions.standard.cu3 import Cu3Gate
+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
 
diff --git a/qiskit/extensions/quantum_initializer/initializer.py b/qiskit/extensions/quantum_initializer/initializer.py
index 3725422646c6..b728ecd50ce9 100644
--- a/qiskit/extensions/quantum_initializer/initializer.py
+++ b/qiskit/extensions/quantum_initializer/initializer.py
@@ -23,7 +23,7 @@
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
 from qiskit.circuit import Instruction
-from qiskit.extensions.standard.cx import CnotGate
+from qiskit.extensions.standard.x import CnotGate
 from qiskit.extensions.standard.ry import RYGate
 from qiskit.extensions.standard.rz import RZGate
 from qiskit.circuit.reset import Reset
diff --git a/qiskit/extensions/standard/__init__.py b/qiskit/extensions/standard/__init__.py
index 8ee3db8bdacd..4d21ef78f338 100644
--- a/qiskit/extensions/standard/__init__.py
+++ b/qiskit/extensions/standard/__init__.py
@@ -14,34 +14,21 @@
 
 """Standard gates."""
 from .barrier import Barrier
-from .ccx import ToffoliGate
-from .cswap import FredkinGate
-from .cx import CnotGate
-from .cy import CyGate
-from .cz import CzGate
-from .swap import SwapGate
-from .h import HGate
+from .h import HGate, CHGate
 from .iden import IdGate
-from .s import SGate
-from .s import SdgGate
-from .t import TGate
-from .t import TdgGate
-from .u1 import U1Gate
-from .u2 import U2Gate
-from .u3 import U3Gate
-from .x import XGate
-from .y import YGate
-from .z import ZGate
+from .ms import MSGate
 from .r import RGate
-from .rx import RXGate
-from .ry import RYGate
-from .rz import RZGate
-from .cu1 import Cu1Gate
-from .ch import CHGate
-from .crx import CrxGate
-from .cry import CryGate
-from .crz import CrzGate
-from .cu3 import Cu3Gate
-from .rzz import RZZGate
+from .rx import RXGate, CrxGate
 from .rxx import RXXGate
-from .ms import MSGate
+from .ry import RYGate, CryGate
+from .rz import RZGate, CrzGate
+from .rzz import RZZGate
+from .s import SGate, SdgGate
+from .swap import SwapGate, FredkinGate
+from .t import TGate, TdgGate
+from .u1 import U1Gate, Cu1Gate
+from .u2 import U2Gate
+from .u3 import U3Gate, Cu3Gate
+from .x import XGate, CnotGate, ToffoliGate
+from .y import YGate, CyGate
+from .z import ZGate, CzGate
diff --git a/qiskit/extensions/standard/ccx.py b/qiskit/extensions/standard/ccx.py
index 099c51c592e6..685d996265af 100644
--- a/qiskit/extensions/standard/ccx.py
+++ b/qiskit/extensions/standard/ccx.py
@@ -16,79 +16,9 @@
 Toffoli gate. Controlled-Controlled-X.
 """
 
-import numpy
+import warnings
+# pylint: disable=unused-import
+from qiskit.extensions.standard.x import ToffoliGate, ccx
 
-from qiskit.circuit import ControlledGate
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.x import XGate
-from qiskit.extensions.standard.h import HGate
-from qiskit.extensions.standard.cx import CnotGate
-from qiskit.extensions.standard.t import TGate
-from qiskit.extensions.standard.t import TdgGate
-
-
-class ToffoliGate(ControlledGate):
-    """Toffoli gate."""
-
-    def __init__(self):
-        """Create new Toffoli gate."""
-        super().__init__("ccx", 3, [], num_ctrl_qubits=2)
-        self.base_gate = XGate
-        self.base_gate_name = "x"
-
-    def _define(self):
-        """
-        gate ccx a,b,c
-        {
-        h c; cx b,c; tdg c; cx a,c;
-        t c; cx b,c; tdg c; cx a,c;
-        t b; t c; h c; cx a,b;
-        t a; tdg b; cx a,b;}
-        """
-        definition = []
-        q = QuantumRegister(3, "q")
-        rule = [
-            (HGate(), [q[2]], []),
-            (CnotGate(), [q[1], q[2]], []),
-            (TdgGate(), [q[2]], []),
-            (CnotGate(), [q[0], q[2]], []),
-            (TGate(), [q[2]], []),
-            (CnotGate(), [q[1], q[2]], []),
-            (TdgGate(), [q[2]], []),
-            (CnotGate(), [q[0], q[2]], []),
-            (TGate(), [q[1]], []),
-            (TGate(), [q[2]], []),
-            (HGate(), [q[2]], []),
-            (CnotGate(), [q[0], q[1]], []),
-            (TGate(), [q[0]], []),
-            (TdgGate(), [q[1]], []),
-            (CnotGate(), [q[0], q[1]], [])
-        ]
-        for inst in rule:
-            definition.append(inst)
-        self.definition = definition
-
-    def inverse(self):
-        """Invert this gate."""
-        return ToffoliGate()  # self-inverse
-
-    def to_matrix(self):
-        """Return a Numpy.array for the Toffoli gate."""
-        return numpy.array([[1, 0, 0, 0, 0, 0, 0, 0],
-                            [0, 1, 0, 0, 0, 0, 0, 0],
-                            [0, 0, 1, 0, 0, 0, 0, 0],
-                            [0, 0, 0, 0, 0, 0, 0, 1],
-                            [0, 0, 0, 0, 1, 0, 0, 0],
-                            [0, 0, 0, 0, 0, 1, 0, 0],
-                            [0, 0, 0, 0, 0, 0, 1, 0],
-                            [0, 0, 0, 1, 0, 0, 0, 0]], dtype=complex)
-
-
-def ccx(self, ctl1, ctl2, tgt):
-    """Apply Toffoli to ctl1 and ctl2 to tgt."""
-    return self.append(ToffoliGate(), [ctl1, ctl2, tgt], [])
-
-
-QuantumCircuit.ccx = ccx
-QuantumCircuit.toffoli = ccx
+warnings.warn('This module is deprecated. The ToffoliGate can now be found in x.py',
+              category=DeprecationWarning, stacklevel=2)
diff --git a/qiskit/extensions/standard/ch.py b/qiskit/extensions/standard/ch.py
index 5f27d2507cea..c6223843cac0 100644
--- a/qiskit/extensions/standard/ch.py
+++ b/qiskit/extensions/standard/ch.py
@@ -15,68 +15,9 @@
 """
 controlled-H gate.
 """
-import numpy as np
+import warnings
+# pylint: disable=unused-import
+from qiskit.extensions.standard.h import HGate, ch
 
-from qiskit.circuit import ControlledGate
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.h import HGate
-from qiskit.extensions.standard.cx import CnotGate
-from qiskit.extensions.standard.t import TGate, TdgGate
-from qiskit.extensions.standard.s import SGate, SdgGate
-
-
-class CHGate(ControlledGate):
-    """controlled-H gate."""
-
-    def __init__(self):
-        """Create new CH gate."""
-        super().__init__("ch", 2, [], num_ctrl_qubits=1)
-        self.base_gate = HGate
-        self.base_gate_name = "h"
-
-    def _define(self):
-        """
-        gate ch a,b {
-            s b;
-            h b;
-            t b;
-            cx a, b;
-            tdg b;
-            h b;
-            sdg b;
-        }
-        """
-        definition = []
-        q = QuantumRegister(2, "q")
-        rule = [
-            (SGate(), [q[1]], []),
-            (HGate(), [q[1]], []),
-            (TGate(), [q[1]], []),
-            (CnotGate(), [q[0], q[1]], []),
-            (TdgGate(), [q[1]], []),
-            (HGate(), [q[1]], []),
-            (SdgGate(), [q[1]], [])
-        ]
-        for inst in rule:
-            definition.append(inst)
-        self.definition = definition
-
-    def inverse(self):
-        """Invert this gate."""
-        return CHGate()  # self-inverse
-
-    def to_matrix(self):
-        """Return a Numpy.array for the Ch gate."""
-        return np.array([[1, 0, 0, 0],
-                         [0, 1/np.sqrt(2), 0, 1/np.sqrt(2)],
-                         [0, 0, 1, 0],
-                         [0, 1/np.sqrt(2), 0, -1/np.sqrt(2)]], dtype=complex)
-
-
-def ch(self, ctl, tgt):  # pylint: disable=invalid-name
-    """Apply CH from ctl to tgt."""
-    return self.append(CHGate(), [ctl, tgt], [])
-
-
-QuantumCircuit.ch = ch
+warnings.warn('This module is deprecated. The CHGate can now be found in h.py',
+              category=DeprecationWarning, stacklevel=2)
diff --git a/qiskit/extensions/standard/crx.py b/qiskit/extensions/standard/crx.py
index ca72352376dd..cc8b4f373e87 100644
--- a/qiskit/extensions/standard/crx.py
+++ b/qiskit/extensions/standard/crx.py
@@ -15,56 +15,9 @@
 """
 controlled-rx gate.
 """
-from qiskit.circuit import ControlledGate
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.u1 import U1Gate
-from qiskit.extensions.standard.u3 import U3Gate
-from qiskit.extensions.standard.rx import RXGate
-from qiskit.extensions.standard.cx import CnotGate
-from qiskit.qasm import pi
+import warnings
+# pylint: disable=unused-import
+from qiskit.extensions.standard.rx import CrxGate, crx
 
-
-class CrxGate(ControlledGate):
-    """controlled-rx gate."""
-
-    def __init__(self, theta):
-        """Create new crx gate."""
-        super().__init__('crx', 2, [theta], num_ctrl_qubits=1)
-        self.base_gate = RXGate
-        self.base_gate_name = 'rx'
-
-    def _define(self):
-        """
-        gate cu3(theta,phi,lambda) c, t
-        { u1(pi/2) t;
-          cx c,t;
-          u3(-theta/2,0,0) t;
-          cx c,t;
-          u3(theta/2,-pi/2,0) t;
-        }
-        """
-        definition = []
-        q = QuantumRegister(2, 'q')
-        rule = [
-            (U1Gate(pi / 2), [q[1]], []),
-            (CnotGate(), [q[0], q[1]], []),
-            (U3Gate(-self.params[0] / 2, 0, 0), [q[1]], []),
-            (CnotGate(), [q[0], q[1]], []),
-            (U3Gate(self.params[0] / 2, -pi / 2, 0), [q[1]], [])
-        ]
-        for inst in rule:
-            definition.append(inst)
-        self.definition = definition
-
-    def inverse(self):
-        """Invert this gate."""
-        return CrxGate(-self.params[0])
-
-
-def crx(self, theta, ctl, tgt):
-    """Apply crx from ctl to tgt with angle theta."""
-    return self.append(CrxGate(theta), [ctl, tgt], [])
-
-
-QuantumCircuit.crx = crx
+warnings.warn('This module is deprecated. The CrxGate can now be found in rx.py',
+              category=DeprecationWarning, stacklevel=2)
diff --git a/qiskit/extensions/standard/cry.py b/qiskit/extensions/standard/cry.py
index 5f0a848e9019..91d0ad400934 100644
--- a/qiskit/extensions/standard/cry.py
+++ b/qiskit/extensions/standard/cry.py
@@ -15,51 +15,9 @@
 """
 controlled-ry gate.
 """
-from qiskit.circuit import ControlledGate
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.u1 import U3Gate
-from qiskit.extensions.standard.cx import CnotGate
-from qiskit.extensions.standard.ry import RYGate
+import warnings
+# pylint: disable=unused-import
+from qiskit.extensions.standard.ry import CryGate, cry
 
-
-class CryGate(ControlledGate):
-    """controlled-ry gate."""
-
-    def __init__(self, theta):
-        """Create new cry gate."""
-        super().__init__("cry", 2, [theta], num_ctrl_qubits=1)
-        self.base_gate = RYGate
-        self.base_gate_name = "ry"
-
-    def _define(self):
-        """
-        gate cry(lambda) a,b
-        { u3(lambda/2,0,0) b; cx a,b;
-          u3(-lambda/2,0,0) b; cx a,b;
-        }
-
-        """
-        definition = []
-        q = QuantumRegister(2, "q")
-        rule = [
-            (U3Gate(self.params[0] / 2, 0, 0), [q[1]], []),
-            (CnotGate(), [q[0], q[1]], []),
-            (U3Gate(-self.params[0] / 2, 0, 0), [q[1]], []),
-            (CnotGate(), [q[0], q[1]], [])
-        ]
-        for inst in rule:
-            definition.append(inst)
-        self.definition = definition
-
-    def inverse(self):
-        """Invert this gate."""
-        return CryGate(-self.params[0])
-
-
-def cry(self, theta, ctl, tgt):
-    """Apply cry from ctl to tgt with angle theta."""
-    return self.append(CryGate(theta), [ctl, tgt], [])
-
-
-QuantumCircuit.cry = cry
+warnings.warn('This module is deprecated. The CryGate can now be found in ry.py',
+              category=DeprecationWarning, stacklevel=2)
diff --git a/qiskit/extensions/standard/crz.py b/qiskit/extensions/standard/crz.py
index 49837de6de60..4b582257ffc5 100644
--- a/qiskit/extensions/standard/crz.py
+++ b/qiskit/extensions/standard/crz.py
@@ -15,50 +15,9 @@
 """
 controlled-rz gate.
 """
-from qiskit.circuit import ControlledGate
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.u1 import U1Gate
-from qiskit.extensions.standard.cx import CnotGate
-from qiskit.extensions.standard.rz import RZGate
+import warnings
+# pylint: disable=unused-import
+from qiskit.extensions.standard.rz import CrzGate, crz
 
-
-class CrzGate(ControlledGate):
-    """controlled-rz gate."""
-
-    def __init__(self, theta):
-        """Create new crz gate."""
-        super().__init__("crz", 2, [theta], num_ctrl_qubits=1)
-        self.base_gate = RZGate
-        self.base_gate_name = "rz"
-
-    def _define(self):
-        """
-        gate crz(lambda) a,b
-        { u1(lambda/2) b; cx a,b;
-          u1(-lambda/2) b; cx a,b;
-        }
-        """
-        definition = []
-        q = QuantumRegister(2, "q")
-        rule = [
-            (U1Gate(self.params[0] / 2), [q[1]], []),
-            (CnotGate(), [q[0], q[1]], []),
-            (U1Gate(-self.params[0] / 2), [q[1]], []),
-            (CnotGate(), [q[0], q[1]], [])
-        ]
-        for inst in rule:
-            definition.append(inst)
-        self.definition = definition
-
-    def inverse(self):
-        """Invert this gate."""
-        return CrzGate(-self.params[0])
-
-
-def crz(self, theta, ctl, tgt):
-    """Apply crz from ctl to tgt with angle theta."""
-    return self.append(CrzGate(theta), [ctl, tgt], [])
-
-
-QuantumCircuit.crz = crz
+warnings.warn('This module is deprecated. The CrzGate can now be found in rz.py',
+              category=DeprecationWarning, stacklevel=2)
diff --git a/qiskit/extensions/standard/cswap.py b/qiskit/extensions/standard/cswap.py
index 608d82976b7b..48e4d9ee7cd4 100644
--- a/qiskit/extensions/standard/cswap.py
+++ b/qiskit/extensions/standard/cswap.py
@@ -15,51 +15,9 @@
 """
 Fredkin gate. Controlled-SWAP.
 """
-from qiskit.circuit import ControlledGate
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.cx import CnotGate
-from qiskit.extensions.standard.ccx import ToffoliGate
-from qiskit.extensions.standard.swap import SwapGate
+import warnings
+# pylint: disable=unused-import
+from qiskit.extensions.standard.swap import FredkinGate, cswap
 
-
-class FredkinGate(ControlledGate):
-    """Fredkin gate."""
-
-    def __init__(self):
-        """Create new Fredkin gate."""
-        super().__init__("cswap", 3, [], num_ctrl_qubits=1)
-        self.base_gate = SwapGate
-        self.base_gate_name = "swap"
-
-    def _define(self):
-        """
-        gate cswap a,b,c
-        { cx c,b;
-          ccx a,b,c;
-          cx c,b;
-        }
-        """
-        definition = []
-        q = QuantumRegister(3, "q")
-        rule = [
-            (CnotGate(), [q[2], q[1]], []),
-            (ToffoliGate(), [q[0], q[1], q[2]], []),
-            (CnotGate(), [q[2], q[1]], [])
-        ]
-        for inst in rule:
-            definition.append(inst)
-        self.definition = definition
-
-    def inverse(self):
-        """Invert this gate."""
-        return FredkinGate()  # self-inverse
-
-
-def cswap(self, ctl, tgt1, tgt2):
-    """Apply Fredkin to circuit."""
-    return self.append(FredkinGate(), [ctl, tgt1, tgt2], [])
-
-
-QuantumCircuit.cswap = cswap
-QuantumCircuit.fredkin = cswap
+warnings.warn('This module is deprecated. The FredkinGate can now be found in swap.py',
+              category=DeprecationWarning, stacklevel=2)
diff --git a/qiskit/extensions/standard/cu1.py b/qiskit/extensions/standard/cu1.py
index 0a987b717d8d..0f671409ee82 100644
--- a/qiskit/extensions/standard/cu1.py
+++ b/qiskit/extensions/standard/cu1.py
@@ -15,51 +15,9 @@
 """
 controlled-u1 gate.
 """
-from qiskit.circuit import ControlledGate
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.u1 import U1Gate
-from qiskit.extensions.standard.cx import CnotGate
+import warnings
+# pylint: disable=unused-import
+from qiskit.extensions.standard.u1 import Cu1Gate, cu1
 
-
-class Cu1Gate(ControlledGate):
-    """controlled-u1 gate."""
-
-    def __init__(self, theta):
-        """Create new cu1 gate."""
-        super().__init__("cu1", 2, [theta], num_ctrl_qubits=1)
-        self.base_gate = U1Gate
-        self.base_gate_name = "u1"
-
-    def _define(self):
-        """
-        gate cu1(lambda) a,b
-        { u1(lambda/2) a; cx a,b;
-          u1(-lambda/2) b; cx a,b;
-          u1(lambda/2) b;
-        }
-        """
-        definition = []
-        q = QuantumRegister(2, "q")
-        rule = [
-            (U1Gate(self.params[0] / 2), [q[0]], []),
-            (CnotGate(), [q[0], q[1]], []),
-            (U1Gate(-self.params[0] / 2), [q[1]], []),
-            (CnotGate(), [q[0], q[1]], []),
-            (U1Gate(self.params[0] / 2), [q[1]], [])
-        ]
-        for inst in rule:
-            definition.append(inst)
-        self.definition = definition
-
-    def inverse(self):
-        """Invert this gate."""
-        return Cu1Gate(-self.params[0])
-
-
-def cu1(self, theta, ctl, tgt):
-    """Apply cu1 from ctl to tgt with angle theta."""
-    return self.append(Cu1Gate(theta), [ctl, tgt], [])
-
-
-QuantumCircuit.cu1 = cu1
+warnings.warn('This module is deprecated. The Cu1Gate can now be found in u1.py',
+              category=DeprecationWarning, stacklevel=2)
diff --git a/qiskit/extensions/standard/cu3.py b/qiskit/extensions/standard/cu3.py
index 95ce2fb6fd73..ecc5504b18a3 100644
--- a/qiskit/extensions/standard/cu3.py
+++ b/qiskit/extensions/standard/cu3.py
@@ -15,56 +15,9 @@
 """
 controlled-u3 gate.
 """
-from qiskit.circuit import ControlledGate
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.u1 import U1Gate
-from qiskit.extensions.standard.u3 import U3Gate
-from qiskit.extensions.standard.cx import CnotGate
+import warnings
+# pylint: disable=unused-import
+from qiskit.extensions.standard.u3 import Cu3Gate, cu3
 
-
-class Cu3Gate(ControlledGate):
-    """controlled-u3 gate."""
-
-    def __init__(self, theta, phi, lam):
-        """Create new cu3 gate."""
-        super().__init__("cu3", 2, [theta, phi, lam], num_ctrl_qubits=1)
-        self.base_gate = U3Gate
-        self.base_gate_name = "u3"
-
-    def _define(self):
-        """
-        gate cu3(theta,phi,lambda) c, t
-        { u1((lambda+phi)/2) c;
-          u1((lambda-phi)/2) t;
-          cx c,t;
-          u3(-theta/2,0,-(phi+lambda)/2) t;
-          cx c,t;
-          u3(theta/2,phi,0) t;
-        }
-        """
-        definition = []
-        q = QuantumRegister(2, "q")
-        rule = [
-            (U1Gate((self.params[2] + self.params[1]) / 2), [q[0]], []),
-            (U1Gate((self.params[2] - self.params[1]) / 2), [q[1]], []),
-            (CnotGate(), [q[0], q[1]], []),
-            (U3Gate(-self.params[0] / 2, 0, -(self.params[1] + self.params[2]) / 2), [q[1]], []),
-            (CnotGate(), [q[0], q[1]], []),
-            (U3Gate(self.params[0] / 2, self.params[1], 0), [q[1]], [])
-        ]
-        for inst in rule:
-            definition.append(inst)
-        self.definition = definition
-
-    def inverse(self):
-        """Invert this gate."""
-        return Cu3Gate(-self.params[0], -self.params[2], -self.params[1])
-
-
-def cu3(self, theta, phi, lam, ctl, tgt):
-    """Apply cu3 from ctl to tgt with angle theta, phi, lam."""
-    return self.append(Cu3Gate(theta, phi, lam), [ctl, tgt], [])
-
-
-QuantumCircuit.cu3 = cu3
+warnings.warn('This module is deprecated. The Cu3Gate can now be found in u3.py',
+              category=DeprecationWarning, stacklevel=2)
diff --git a/qiskit/extensions/standard/cx.py b/qiskit/extensions/standard/cx.py
index a77ffcc38b9d..0562ad745fb6 100644
--- a/qiskit/extensions/standard/cx.py
+++ b/qiskit/extensions/standard/cx.py
@@ -15,38 +15,9 @@
 """
 controlled-NOT gate.
 """
-import numpy
+import warnings
+# pylint: disable=unused-import
+from qiskit.extensions.standard.x import CnotGate, cx
 
-from qiskit.circuit import ControlledGate
-from qiskit.circuit import QuantumCircuit
-from qiskit.extensions.standard.x import XGate
-
-
-class CnotGate(ControlledGate):
-    """controlled-NOT gate."""
-
-    def __init__(self):
-        """Create new CNOT gate."""
-        super().__init__("cx", 2, [], num_ctrl_qubits=1)
-        self.base_gate = XGate
-        self.base_gate_name = "x"
-
-    def inverse(self):
-        """Invert this gate."""
-        return CnotGate()  # self-inverse
-
-    def to_matrix(self):
-        """Return a Numpy.array for the Cx gate."""
-        return numpy.array([[1, 0, 0, 0],
-                            [0, 0, 0, 1],
-                            [0, 0, 1, 0],
-                            [0, 1, 0, 0]], dtype=complex)
-
-
-def cx(self, ctl, tgt):  # pylint: disable=invalid-name
-    """Apply CX from ctl to tgt."""
-    return self.append(CnotGate(), [ctl, tgt], [])
-
-
-QuantumCircuit.cx = cx
-QuantumCircuit.cnot = cx
+warnings.warn('This module is deprecated. The CnotGate can now be found in x.py',
+              category=DeprecationWarning, stacklevel=2)
diff --git a/qiskit/extensions/standard/cy.py b/qiskit/extensions/standard/cy.py
index 74ca97e5f0b3..98157d4b7032 100644
--- a/qiskit/extensions/standard/cy.py
+++ b/qiskit/extensions/standard/cy.py
@@ -15,47 +15,9 @@
 """
 controlled-Y gate.
 """
-from qiskit.circuit import ControlledGate
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.y import YGate
-from qiskit.extensions.standard.s import SGate
-from qiskit.extensions.standard.s import SdgGate
-from qiskit.extensions.standard.cx import CnotGate
+import warnings
+# pylint: disable=unused-import
+from qiskit.extensions.standard.y import CyGate, cy
 
-
-class CyGate(ControlledGate):
-    """controlled-Y gate."""
-
-    def __init__(self):
-        """Create new CY gate."""
-        super().__init__("cy", 2, [], num_ctrl_qubits=1)
-        self.base_gate = YGate
-        self.base_gate_name = "y"
-
-    def _define(self):
-        """
-        gate cy a,b { sdg b; cx a,b; s b; }
-        """
-        definition = []
-        q = QuantumRegister(2, "q")
-        rule = [
-            (SdgGate(), [q[1]], []),
-            (CnotGate(), [q[0], q[1]], []),
-            (SGate(), [q[1]], [])
-        ]
-        for inst in rule:
-            definition.append(inst)
-        self.definition = definition
-
-    def inverse(self):
-        """Invert this gate."""
-        return CyGate()  # self-inverse
-
-
-def cy(self, ctl, tgt):  # pylint: disable=invalid-name
-    """Apply CY to circuit."""
-    return self.append(CyGate(), [ctl, tgt], [])
-
-
-QuantumCircuit.cy = cy
+warnings.warn('This module is deprecated. The CyGate can now be found in y.py',
+              category=DeprecationWarning, stacklevel=2)
diff --git a/qiskit/extensions/standard/cz.py b/qiskit/extensions/standard/cz.py
index a0b8edff1469..37be8f528c2f 100644
--- a/qiskit/extensions/standard/cz.py
+++ b/qiskit/extensions/standard/cz.py
@@ -15,55 +15,9 @@
 """
 controlled-Phase gate.
 """
-import numpy
+import warnings
+# pylint: disable=unused-import
+from qiskit.extensions.standard.z import CzGate, cz
 
-from qiskit.circuit import ControlledGate
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.h import HGate
-from qiskit.extensions.standard.cx import CnotGate
-from qiskit.extensions.standard.z import ZGate
-
-
-class CzGate(ControlledGate):
-    """controlled-Z gate."""
-
-    def __init__(self, label=None):
-        """Create new CZ gate."""
-        super().__init__("cz", 2, [], label=label, num_ctrl_qubits=1)
-        self.base_gate = ZGate
-        self.base_gate_name = "z"
-
-    def _define(self):
-        """
-        gate cz a,b { h b; cx a,b; h b; }
-        """
-        definition = []
-        q = QuantumRegister(2, "q")
-        rule = [
-            (HGate(), [q[1]], []),
-            (CnotGate(), [q[0], q[1]], []),
-            (HGate(), [q[1]], [])
-        ]
-        for inst in rule:
-            definition.append(inst)
-        self.definition = definition
-
-    def inverse(self):
-        """Invert this gate."""
-        return CzGate()  # self-inverse
-
-    def to_matrix(self):
-        """Return a Numpy.array for the Cz gate."""
-        return numpy.array([[1, 0, 0, 0],
-                            [0, 1, 0, 0],
-                            [0, 0, 1, 0],
-                            [0, 0, 0, -1]], dtype=complex)
-
-
-def cz(self, ctl, tgt):  # pylint: disable=invalid-name
-    """Apply CZ to circuit."""
-    return self.append(CzGate(), [ctl, tgt], [])
-
-
-QuantumCircuit.cz = cz
+warnings.warn('This module is deprecated. The CzGate can now be found in z.py',
+              category=DeprecationWarning, stacklevel=2)
diff --git a/qiskit/extensions/standard/h.py b/qiskit/extensions/standard/h.py
index d3a698ca2e91..4177f412a033 100644
--- a/qiskit/extensions/standard/h.py
+++ b/qiskit/extensions/standard/h.py
@@ -16,14 +16,14 @@
 Hadamard gate.
 """
 import numpy
-
 from qiskit.circuit import Gate
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
+from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.qasm import pi
-from qiskit.extensions.standard.u2 import U2Gate
 
 
+# pylint: disable=cyclic-import
 class HGate(Gate):
     """Hadamard gate."""
 
@@ -35,6 +35,7 @@ def _define(self):
         """
         gate h a { u2(0,pi) a; }
         """
+        from qiskit.extensions.standard.u2 import U2Gate
         definition = []
         q = QuantumRegister(1, "q")
         rule = [
@@ -44,6 +45,20 @@ def _define(self):
             definition.append(inst)
         self.definition = definition
 
+    def control(self, num_ctrl_qubits=1, label=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]
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if num_ctrl_qubits == 1:
+            return CHGate()
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label)
+
     def inverse(self):
         """Invert this gate."""
         return HGate()  # self-inverse
@@ -60,3 +75,62 @@ def h(self, q):  # pylint: disable=invalid-name
 
 
 QuantumCircuit.h = h
+
+
+class CHGate(ControlledGate):
+    """controlled-H gate."""
+
+    def __init__(self):
+        """Create new CH gate."""
+        super().__init__("ch", 2, [], num_ctrl_qubits=1)
+        self.base_gate = HGate
+        self.base_gate_name = "h"
+
+    def _define(self):
+        """
+        gate ch a,b {
+            s b;
+            h b;
+            t b;
+            cx a, b;
+            tdg b;
+            h b;
+            sdg b;
+        }
+        """
+        from qiskit.extensions.standard.s import SGate, SdgGate
+        from qiskit.extensions.standard.t import TGate, TdgGate
+        from qiskit.extensions.standard.x import CnotGate
+        definition = []
+        q = QuantumRegister(2, "q")
+        rule = [
+            (SGate(), [q[1]], []),
+            (HGate(), [q[1]], []),
+            (TGate(), [q[1]], []),
+            (CnotGate(), [q[0], q[1]], []),
+            (TdgGate(), [q[1]], []),
+            (HGate(), [q[1]], []),
+            (SdgGate(), [q[1]], [])
+        ]
+        for inst in rule:
+            definition.append(inst)
+        self.definition = definition
+
+    def inverse(self):
+        """Invert this gate."""
+        return CHGate()  # self-inverse
+
+    def to_matrix(self):
+        """Return a Numpy.array for the Ch gate."""
+        return numpy.array([[1, 0, 0, 0],
+                            [0, 1/numpy.sqrt(2), 0, 1/numpy.sqrt(2)],
+                            [0, 0, 1, 0],
+                            [0, 1/numpy.sqrt(2), 0, -1/numpy.sqrt(2)]], dtype=complex)
+
+
+def ch(self, ctl, tgt):  # pylint: disable=invalid-name
+    """Apply CH from ctl to tgt."""
+    return self.append(CHGate(), [ctl, tgt], [])
+
+
+QuantumCircuit.ch = ch
diff --git a/qiskit/extensions/standard/ms.py b/qiskit/extensions/standard/ms.py
index dad447f10d70..161704ce1f45 100755
--- a/qiskit/extensions/standard/ms.py
+++ b/qiskit/extensions/standard/ms.py
@@ -28,7 +28,6 @@
 from qiskit.circuit import Gate
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.rxx import RXXGate
 
 
 class MSGate(Gate):
@@ -39,6 +38,7 @@ def __init__(self, n_qubits, theta):
         super().__init__("ms", n_qubits, [theta])
 
     def _define(self):
+        from qiskit.extensions.standard.rxx import RXXGate
         definition = []
         q = QuantumRegister(self.num_qubits, "q")
         rule = []
diff --git a/qiskit/extensions/standard/r.py b/qiskit/extensions/standard/r.py
index 89e7c11f4034..dd0b8c13fec3 100644
--- a/qiskit/extensions/standard/r.py
+++ b/qiskit/extensions/standard/r.py
@@ -21,7 +21,6 @@
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
 from qiskit.qasm import pi
-from qiskit.extensions.standard.u3 import U3Gate
 
 
 class RGate(Gate):
@@ -35,6 +34,7 @@ def _define(self):
         """
         gate r(θ, φ) a {u3(θ, φ - π/2, -φ + π/2) a;}
         """
+        from qiskit.extensions.standard.u3 import U3Gate
         definition = []
         q = QuantumRegister(1, "q")
         theta = self.params[0]
diff --git a/qiskit/extensions/standard/rx.py b/qiskit/extensions/standard/rx.py
index 25cc7bf9a5ad..db670d3efbee 100644
--- a/qiskit/extensions/standard/rx.py
+++ b/qiskit/extensions/standard/rx.py
@@ -17,10 +17,11 @@
 """
 import math
 import numpy
+from qiskit.circuit import ControlledGate
 from qiskit.circuit import Gate
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.r import RGate
+from qiskit.qasm import pi
 
 
 class RXGate(Gate):
@@ -34,6 +35,7 @@ def _define(self):
         """
         gate rx(theta) a {r(theta, 0) a;}
         """
+        from qiskit.extensions.standard.r import RGate
         definition = []
         q = QuantumRegister(1, "q")
         rule = [
@@ -43,6 +45,20 @@ def _define(self):
             definition.append(inst)
         self.definition = definition
 
+    def control(self, num_ctrl_qubits=1, label=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]
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if num_ctrl_qubits == 1:
+            return CrxGate(self.params[0])
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label)
+
     def inverse(self):
         """Invert this gate.
 
@@ -64,3 +80,51 @@ def rx(self, theta, q):  # pylint: disable=invalid-name
 
 
 QuantumCircuit.rx = rx
+
+
+class CrxGate(ControlledGate):
+    """controlled-rx gate."""
+
+    def __init__(self, theta):
+        """Create new crx gate."""
+        super().__init__('crx', 2, [theta], num_ctrl_qubits=1)
+        self.base_gate = RXGate
+        self.base_gate_name = 'rx'
+
+    def _define(self):
+        """
+        gate cu3(theta,phi,lambda) c, t
+        { u1(pi/2) t;
+          cx c,t;
+          u3(-theta/2,0,0) t;
+          cx c,t;
+          u3(theta/2,-pi/2,0) t;
+        }
+        """
+        from qiskit.extensions.standard.u1 import U1Gate
+        from qiskit.extensions.standard.u3 import U3Gate
+        from qiskit.extensions.standard.x import CnotGate
+        definition = []
+        q = QuantumRegister(2, 'q')
+        rule = [
+            (U1Gate(pi / 2), [q[1]], []),
+            (CnotGate(), [q[0], q[1]], []),
+            (U3Gate(-self.params[0] / 2, 0, 0), [q[1]], []),
+            (CnotGate(), [q[0], q[1]], []),
+            (U3Gate(self.params[0] / 2, -pi / 2, 0), [q[1]], [])
+        ]
+        for inst in rule:
+            definition.append(inst)
+        self.definition = definition
+
+    def inverse(self):
+        """Invert this gate."""
+        return CrxGate(-self.params[0])
+
+
+def crx(self, theta, ctl, tgt):
+    """Apply crx from ctl to tgt with angle theta."""
+    return self.append(CrxGate(theta), [ctl, tgt], [])
+
+
+QuantumCircuit.crx = crx
diff --git a/qiskit/extensions/standard/rxx.py b/qiskit/extensions/standard/rxx.py
index ea210ae45fed..5c5dcf726956 100644
--- a/qiskit/extensions/standard/rxx.py
+++ b/qiskit/extensions/standard/rxx.py
@@ -19,11 +19,6 @@
 from qiskit.circuit import Gate
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.cx import CnotGate
-from qiskit.extensions.standard.u1 import U1Gate
-from qiskit.extensions.standard.u2 import U2Gate
-from qiskit.extensions.standard.u3 import U3Gate
-from qiskit.extensions.standard.h import HGate
 
 
 class RXXGate(Gate):
@@ -38,6 +33,11 @@ def __init__(self, theta):
 
     def _define(self):
         """Calculate a subcircuit that implements this unitary."""
+        from qiskit.extensions.standard.x import CnotGate
+        from qiskit.extensions.standard.u1 import U1Gate
+        from qiskit.extensions.standard.u2 import U2Gate
+        from qiskit.extensions.standard.u3 import U3Gate
+        from qiskit.extensions.standard.h import HGate
         definition = []
         q = QuantumRegister(2, "q")
         theta = self.params[0]
diff --git a/qiskit/extensions/standard/ry.py b/qiskit/extensions/standard/ry.py
index cd9f5aa699fd..b4ad80a343ba 100644
--- a/qiskit/extensions/standard/ry.py
+++ b/qiskit/extensions/standard/ry.py
@@ -17,11 +17,11 @@
 """
 import math
 import numpy
+from qiskit.circuit import ControlledGate
 from qiskit.circuit import Gate
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
 from qiskit.qasm import pi
-from qiskit.extensions.standard.r import RGate
 
 
 class RYGate(Gate):
@@ -35,6 +35,7 @@ def _define(self):
         """
         gate ry(theta) a { r(theta, pi/2) a; }
         """
+        from qiskit.extensions.standard.r import RGate
         definition = []
         q = QuantumRegister(1, "q")
         rule = [
@@ -44,6 +45,20 @@ def _define(self):
             definition.append(inst)
         self.definition = definition
 
+    def control(self, num_ctrl_qubits=1, label=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]
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if num_ctrl_qubits == 1:
+            return CryGate(self.params[0])
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label)
+
     def inverse(self):
         """Invert this gate.
 
@@ -65,3 +80,47 @@ def ry(self, theta, q):  # pylint: disable=invalid-name
 
 
 QuantumCircuit.ry = ry
+
+
+class CryGate(ControlledGate):
+    """controlled-ry gate."""
+
+    def __init__(self, theta):
+        """Create new cry gate."""
+        super().__init__("cry", 2, [theta], num_ctrl_qubits=1)
+        self.base_gate = RYGate
+        self.base_gate_name = "ry"
+
+    def _define(self):
+        """
+        gate cry(lambda) a,b
+        { u3(lambda/2,0,0) b; cx a,b;
+          u3(-lambda/2,0,0) b; cx a,b;
+        }
+
+        """
+        from qiskit.extensions.standard.x import CnotGate
+        from qiskit.extensions.standard.u3 import U3Gate
+        definition = []
+        q = QuantumRegister(2, "q")
+        rule = [
+            (U3Gate(self.params[0] / 2, 0, 0), [q[1]], []),
+            (CnotGate(), [q[0], q[1]], []),
+            (U3Gate(-self.params[0] / 2, 0, 0), [q[1]], []),
+            (CnotGate(), [q[0], q[1]], [])
+        ]
+        for inst in rule:
+            definition.append(inst)
+        self.definition = definition
+
+    def inverse(self):
+        """Invert this gate."""
+        return CryGate(-self.params[0])
+
+
+def cry(self, theta, ctl, tgt):
+    """Apply cry from ctl to tgt with angle theta."""
+    return self.append(CryGate(theta), [ctl, tgt], [])
+
+
+QuantumCircuit.cry = cry
diff --git a/qiskit/extensions/standard/rz.py b/qiskit/extensions/standard/rz.py
index 7277de061408..073bd1333673 100644
--- a/qiskit/extensions/standard/rz.py
+++ b/qiskit/extensions/standard/rz.py
@@ -16,9 +16,9 @@
 Rotation around the z-axis.
 """
 from qiskit.circuit import Gate
+from qiskit.circuit import ControlledGate
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.u1 import U1Gate
 
 
 class RZGate(Gate):
@@ -32,6 +32,7 @@ def _define(self):
         """
         gate rz(phi) a { u1(phi) a; }
         """
+        from qiskit.extensions.standard.u1 import U1Gate
         definition = []
         q = QuantumRegister(1, "q")
         rule = [
@@ -41,6 +42,20 @@ def _define(self):
             definition.append(inst)
         self.definition = definition
 
+    def control(self, num_ctrl_qubits=1, label=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]
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if num_ctrl_qubits == 1:
+            return CrzGate(self.params[0])
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label)
+
     def inverse(self):
         """Invert this gate.
 
@@ -55,3 +70,46 @@ def rz(self, phi, q):  # pylint: disable=invalid-name
 
 
 QuantumCircuit.rz = rz
+
+
+class CrzGate(ControlledGate):
+    """controlled-rz gate."""
+
+    def __init__(self, theta):
+        """Create new crz gate."""
+        super().__init__("crz", 2, [theta], num_ctrl_qubits=1)
+        self.base_gate = RZGate
+        self.base_gate_name = "rz"
+
+    def _define(self):
+        """
+        gate crz(lambda) a,b
+        { u1(lambda/2) b; cx a,b;
+          u1(-lambda/2) b; cx a,b;
+        }
+        """
+        from qiskit.extensions.standard.x import CnotGate
+        from qiskit.extensions.standard.u1 import U1Gate
+        definition = []
+        q = QuantumRegister(2, "q")
+        rule = [
+            (U1Gate(self.params[0] / 2), [q[1]], []),
+            (CnotGate(), [q[0], q[1]], []),
+            (U1Gate(-self.params[0] / 2), [q[1]], []),
+            (CnotGate(), [q[0], q[1]], [])
+        ]
+        for inst in rule:
+            definition.append(inst)
+        self.definition = definition
+
+    def inverse(self):
+        """Invert this gate."""
+        return CrzGate(-self.params[0])
+
+
+def crz(self, theta, ctl, tgt):
+    """Apply crz from ctl to tgt with angle theta."""
+    return self.append(CrzGate(theta), [ctl, tgt], [])
+
+
+QuantumCircuit.crz = crz
diff --git a/qiskit/extensions/standard/rzz.py b/qiskit/extensions/standard/rzz.py
index 7cbd396a481a..717fb264dc96 100644
--- a/qiskit/extensions/standard/rzz.py
+++ b/qiskit/extensions/standard/rzz.py
@@ -18,8 +18,6 @@
 from qiskit.circuit import Gate
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.u1 import U1Gate
-from qiskit.extensions.standard.cx import CnotGate
 
 
 class RZZGate(Gate):
@@ -33,6 +31,8 @@ def _define(self):
         """
         gate rzz(theta) a, b { cx a, b; u1(theta) b; cx a, b; }
         """
+        from qiskit.extensions.standard.u1 import U1Gate
+        from qiskit.extensions.standard.x import CnotGate
         definition = []
         q = QuantumRegister(2, "q")
         rule = [
diff --git a/qiskit/extensions/standard/s.py b/qiskit/extensions/standard/s.py
index 6a8c3350d1b1..bf38d4816dcf 100644
--- a/qiskit/extensions/standard/s.py
+++ b/qiskit/extensions/standard/s.py
@@ -20,7 +20,6 @@
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
 from qiskit.qasm import pi
-from qiskit.extensions.standard.u1 import U1Gate
 
 
 class SGate(Gate):
@@ -34,6 +33,7 @@ def _define(self):
         """
         gate s a { u1(pi/2) a; }
         """
+        from qiskit.extensions.standard.u1 import U1Gate
         definition = []
         q = QuantumRegister(1, "q")
         rule = [
@@ -64,6 +64,7 @@ def _define(self):
         """
         gate sdg a { u1(-pi/2) a; }
         """
+        from qiskit.extensions.standard.u1 import U1Gate
         definition = []
         q = QuantumRegister(1, "q")
         rule = [
diff --git a/qiskit/extensions/standard/swap.py b/qiskit/extensions/standard/swap.py
index 545b61c64b32..bcab4401b3ef 100644
--- a/qiskit/extensions/standard/swap.py
+++ b/qiskit/extensions/standard/swap.py
@@ -16,11 +16,10 @@
 SWAP gate.
 """
 import numpy
-
+from qiskit.circuit import ControlledGate
 from qiskit.circuit import Gate
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.cx import CnotGate
 
 
 class SwapGate(Gate):
@@ -34,6 +33,7 @@ def _define(self):
         """
         gate swap a,b { cx a,b; cx b,a; cx a,b; }
         """
+        from qiskit.extensions.standard.x import CnotGate
         definition = []
         q = QuantumRegister(2, "q")
         rule = [
@@ -45,6 +45,20 @@ def _define(self):
             definition.append(inst)
         self.definition = definition
 
+    def control(self, num_ctrl_qubits=1, label=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]
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if num_ctrl_qubits == 1:
+            return FredkinGate()
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label)
+
     def inverse(self):
         """Invert this gate."""
         return SwapGate()  # self-inverse
@@ -63,3 +77,46 @@ def swap(self, qubit1, qubit2):
 
 
 QuantumCircuit.swap = swap
+
+
+class FredkinGate(ControlledGate):
+    """Fredkin gate."""
+
+    def __init__(self):
+        """Create new Fredkin gate."""
+        super().__init__("cswap", 3, [], num_ctrl_qubits=1)
+        self.base_gate = SwapGate
+        self.base_gate_name = "swap"
+
+    def _define(self):
+        """
+        gate cswap a,b,c
+        { cx c,b;
+          ccx a,b,c;
+          cx c,b;
+        }
+        """
+        from qiskit.extensions.standard.x import CnotGate, ToffoliGate
+        definition = []
+        q = QuantumRegister(3, "q")
+        rule = [
+            (CnotGate(), [q[2], q[1]], []),
+            (ToffoliGate(), [q[0], q[1], q[2]], []),
+            (CnotGate(), [q[2], q[1]], [])
+        ]
+        for inst in rule:
+            definition.append(inst)
+        self.definition = definition
+
+    def inverse(self):
+        """Invert this gate."""
+        return FredkinGate()  # self-inverse
+
+
+def cswap(self, ctl, tgt1, tgt2):
+    """Apply Fredkin to circuit."""
+    return self.append(FredkinGate(), [ctl, tgt1, tgt2], [])
+
+
+QuantumCircuit.cswap = cswap
+QuantumCircuit.fredkin = cswap
diff --git a/qiskit/extensions/standard/t.py b/qiskit/extensions/standard/t.py
index 35c9fdc1c4c4..dacc920c08ce 100644
--- a/qiskit/extensions/standard/t.py
+++ b/qiskit/extensions/standard/t.py
@@ -20,7 +20,6 @@
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
 from qiskit.qasm import pi
-from qiskit.extensions.standard.u1 import U1Gate
 
 
 class TGate(Gate):
@@ -34,6 +33,7 @@ def _define(self):
         """
         gate t a { u1(pi/4) a; }
         """
+        from qiskit.extensions.standard.u1 import U1Gate
         definition = []
         q = QuantumRegister(1, "q")
         rule = [
@@ -64,6 +64,7 @@ def _define(self):
         """
         gate t a { u1(pi/4) a; }
         """
+        from qiskit.extensions.standard.u1 import U1Gate
         definition = []
         q = QuantumRegister(1, "q")
         rule = [
diff --git a/qiskit/extensions/standard/u1.py b/qiskit/extensions/standard/u1.py
index 41a2d9358e47..47c56fd3bf54 100644
--- a/qiskit/extensions/standard/u1.py
+++ b/qiskit/extensions/standard/u1.py
@@ -16,12 +16,13 @@
 Diagonal single qubit gate.
 """
 import numpy
+from qiskit.circuit import ControlledGate
 from qiskit.circuit import Gate
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
-from qiskit.extensions.standard.u3 import U3Gate
 
 
+# pylint: disable=cyclic-import
 class U1Gate(Gate):
     """Diagonal single-qubit gate."""
 
@@ -30,6 +31,7 @@ def __init__(self, theta, label=None):
         super().__init__("u1", 1, [theta], label=label)
 
     def _define(self):
+        from qiskit.extensions.standard.u3 import U3Gate
         definition = []
         q = QuantumRegister(1, "q")
         rule = [
@@ -39,6 +41,20 @@ def _define(self):
             definition.append(inst)
         self.definition = definition
 
+    def control(self, num_ctrl_qubits=1, label=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]
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if num_ctrl_qubits == 1:
+            return Cu1Gate(*self.params)
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label)
+
     def inverse(self):
         """Invert this gate."""
         return U1Gate(-self.params[0])
@@ -56,3 +72,47 @@ def u1(self, theta, q):  # pylint: disable=invalid-name
 
 
 QuantumCircuit.u1 = u1
+
+
+class Cu1Gate(ControlledGate):
+    """controlled-u1 gate."""
+
+    def __init__(self, theta):
+        """Create new cu1 gate."""
+        super().__init__("cu1", 2, [theta], num_ctrl_qubits=1)
+        self.base_gate = U1Gate
+        self.base_gate_name = "u1"
+
+    def _define(self):
+        """
+        gate cu1(lambda) a,b
+        { u1(lambda/2) a; cx a,b;
+          u1(-lambda/2) b; cx a,b;
+          u1(lambda/2) b;
+        }
+        """
+        from qiskit.extensions.standard.x import CnotGate
+        definition = []
+        q = QuantumRegister(2, "q")
+        rule = [
+            (U1Gate(self.params[0] / 2), [q[0]], []),
+            (CnotGate(), [q[0], q[1]], []),
+            (U1Gate(-self.params[0] / 2), [q[1]], []),
+            (CnotGate(), [q[0], q[1]], []),
+            (U1Gate(self.params[0] / 2), [q[1]], [])
+        ]
+        for inst in rule:
+            definition.append(inst)
+        self.definition = definition
+
+    def inverse(self):
+        """Invert this gate."""
+        return Cu1Gate(-self.params[0])
+
+
+def cu1(self, theta, ctl, tgt):
+    """Apply cu1 from ctl to tgt with angle theta."""
+    return self.append(Cu1Gate(theta), [ctl, tgt], [])
+
+
+QuantumCircuit.cu1 = cu1
diff --git a/qiskit/extensions/standard/u2.py b/qiskit/extensions/standard/u2.py
index dad746af2f80..57c034fc0e60 100644
--- a/qiskit/extensions/standard/u2.py
+++ b/qiskit/extensions/standard/u2.py
@@ -20,7 +20,6 @@
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
 from qiskit.qasm import pi
-from qiskit.extensions.standard.u3 import U3Gate
 
 
 class U2Gate(Gate):
@@ -31,6 +30,7 @@ def __init__(self, phi, lam, label=None):
         super().__init__("u2", 1, [phi, lam], label=label)
 
     def _define(self):
+        from qiskit.extensions.standard.u3 import U3Gate
         definition = []
         q = QuantumRegister(1, "q")
         rule = [(U3Gate(pi / 2, self.params[0], self.params[1]), [q[0]], [])]
diff --git a/qiskit/extensions/standard/u3.py b/qiskit/extensions/standard/u3.py
index d436cd9b3daa..37f5cd37879c 100644
--- a/qiskit/extensions/standard/u3.py
+++ b/qiskit/extensions/standard/u3.py
@@ -17,10 +17,13 @@
 """
 
 import numpy
+from qiskit.circuit import ControlledGate
 from qiskit.circuit import Gate
 from qiskit.circuit import QuantumCircuit
+from qiskit.circuit import QuantumRegister
 
 
+# pylint: disable=cyclic-import
 class U3Gate(Gate):
     """Two-pulse single-qubit gate."""
 
@@ -35,6 +38,20 @@ def inverse(self):
         """
         return U3Gate(-self.params[0], -self.params[2], -self.params[1])
 
+    def control(self, num_ctrl_qubits=1, label=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]
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if num_ctrl_qubits == 1:
+            return Cu3Gate(*self.params)
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label)
+
     def to_matrix(self):
         """Return a Numpy.array for the U3 gate."""
         theta, phi, lam = self.params
@@ -57,3 +74,52 @@ def u3(self, theta, phi, lam, q):  # pylint: disable=invalid-name
 
 
 QuantumCircuit.u3 = u3
+
+
+class Cu3Gate(ControlledGate):
+    """controlled-u3 gate."""
+
+    def __init__(self, theta, phi, lam):
+        """Create new cu3 gate."""
+        super().__init__("cu3", 2, [theta, phi, lam], num_ctrl_qubits=1)
+        self.base_gate = U3Gate
+        self.base_gate_name = "u3"
+
+    def _define(self):
+        """
+        gate cu3(theta,phi,lambda) c, t
+        { u1((lambda+phi)/2) c;
+          u1((lambda-phi)/2) t;
+          cx c,t;
+          u3(-theta/2,0,-(phi+lambda)/2) t;
+          cx c,t;
+          u3(theta/2,phi,0) t;
+        }
+        """
+        from qiskit.extensions.standard.u1 import U1Gate
+        from qiskit.extensions.standard.x import CnotGate
+        definition = []
+        q = QuantumRegister(2, "q")
+        rule = [
+            (U1Gate((self.params[2] + self.params[1]) / 2), [q[0]], []),
+            (U1Gate((self.params[2] - self.params[1]) / 2), [q[1]], []),
+            (CnotGate(), [q[0], q[1]], []),
+            (U3Gate(-self.params[0] / 2, 0, -(self.params[1] + self.params[2]) / 2), [q[1]], []),
+            (CnotGate(), [q[0], q[1]], []),
+            (U3Gate(self.params[0] / 2, self.params[1], 0), [q[1]], [])
+        ]
+        for inst in rule:
+            definition.append(inst)
+        self.definition = definition
+
+    def inverse(self):
+        """Invert this gate."""
+        return Cu3Gate(-self.params[0], -self.params[2], -self.params[1])
+
+
+def cu3(self, theta, phi, lam, ctl, tgt):
+    """Apply cu3 from ctl to tgt with angle theta, phi, lam."""
+    return self.append(Cu3Gate(theta, phi, lam), [ctl, tgt], [])
+
+
+QuantumCircuit.cu3 = cu3
diff --git a/qiskit/extensions/standard/x.py b/qiskit/extensions/standard/x.py
index e4d73869358e..df0fdd69e5e4 100644
--- a/qiskit/extensions/standard/x.py
+++ b/qiskit/extensions/standard/x.py
@@ -16,12 +16,11 @@
 Pauli X (bit-flip) gate.
 """
 import numpy
-
+from qiskit.circuit import ControlledGate
 from qiskit.circuit import Gate
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
 from qiskit.qasm import pi
-from qiskit.extensions.standard.u3 import U3Gate
 
 
 class XGate(Gate):
@@ -37,6 +36,7 @@ def _define(self):
         u3(pi,0,pi) a;
         }
         """
+        from qiskit.extensions.standard.u3 import U3Gate
         definition = []
         q = QuantumRegister(1, "q")
         rule = [
@@ -46,6 +46,22 @@ def _define(self):
             definition.append(inst)
         self.definition = definition
 
+    def control(self, num_ctrl_qubits=1, label=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]
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if num_ctrl_qubits == 1:
+            return CnotGate()
+        elif num_ctrl_qubits == 2:
+            return ToffoliGate()
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label)
+
     def inverse(self):
         """Invert this gate."""
         return XGate()  # self-inverse
@@ -62,3 +78,116 @@ def x(self, q):
 
 
 QuantumCircuit.x = x
+
+
+class CnotGate(ControlledGate):
+    """controlled-NOT gate."""
+
+    def __init__(self):
+        """Create new CNOT gate."""
+        super().__init__("cx", 2, [], num_ctrl_qubits=1)
+        self.base_gate = XGate
+        self.base_gate_name = "x"
+
+    def control(self, num_ctrl_qubits=1, label=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]
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if num_ctrl_qubits == 1:
+            return ToffoliGate()
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label)
+
+    def inverse(self):
+        """Invert this gate."""
+        return CnotGate()  # self-inverse
+
+    def to_matrix(self):
+        """Return a Numpy.array for the Cx gate."""
+        return numpy.array([[1, 0, 0, 0],
+                            [0, 0, 0, 1],
+                            [0, 0, 1, 0],
+                            [0, 1, 0, 0]], dtype=complex)
+
+
+def cx(self, ctl, tgt):  # pylint: disable=invalid-name
+    """Apply CX from ctl to tgt."""
+    return self.append(CnotGate(), [ctl, tgt], [])
+
+
+QuantumCircuit.cx = cx
+QuantumCircuit.cnot = cx
+
+
+class ToffoliGate(ControlledGate):
+    """Toffoli gate."""
+
+    def __init__(self):
+        """Create new Toffoli gate."""
+        super().__init__("ccx", 3, [], num_ctrl_qubits=2)
+        self.base_gate = XGate
+        self.base_gate_name = "x"
+
+    def _define(self):
+        """
+        gate ccx a,b,c
+        {
+        h c; cx b,c; tdg c; cx a,c;
+        t c; cx b,c; tdg c; cx a,c;
+        t b; t c; h c; cx a,b;
+        t a; tdg b; cx a,b;}
+        """
+        from qiskit.extensions.standard.h import HGate
+        from qiskit.extensions.standard.t import TGate
+        from qiskit.extensions.standard.t import TdgGate
+        definition = []
+        q = QuantumRegister(3, "q")
+        rule = [
+            (HGate(), [q[2]], []),
+            (CnotGate(), [q[1], q[2]], []),
+            (TdgGate(), [q[2]], []),
+            (CnotGate(), [q[0], q[2]], []),
+            (TGate(), [q[2]], []),
+            (CnotGate(), [q[1], q[2]], []),
+            (TdgGate(), [q[2]], []),
+            (CnotGate(), [q[0], q[2]], []),
+            (TGate(), [q[1]], []),
+            (TGate(), [q[2]], []),
+            (HGate(), [q[2]], []),
+            (CnotGate(), [q[0], q[1]], []),
+            (TGate(), [q[0]], []),
+            (TdgGate(), [q[1]], []),
+            (CnotGate(), [q[0], q[1]], [])
+        ]
+        for inst in rule:
+            definition.append(inst)
+        self.definition = definition
+
+    def inverse(self):
+        """Invert this gate."""
+        return ToffoliGate()  # self-inverse
+
+    def to_matrix(self):
+        """Return a Numpy.array for the Toffoli gate."""
+        return numpy.array([[1, 0, 0, 0, 0, 0, 0, 0],
+                            [0, 1, 0, 0, 0, 0, 0, 0],
+                            [0, 0, 1, 0, 0, 0, 0, 0],
+                            [0, 0, 0, 0, 0, 0, 0, 1],
+                            [0, 0, 0, 0, 1, 0, 0, 0],
+                            [0, 0, 0, 0, 0, 1, 0, 0],
+                            [0, 0, 0, 0, 0, 0, 1, 0],
+                            [0, 0, 0, 1, 0, 0, 0, 0]], dtype=complex)
+
+
+def ccx(self, ctl1, ctl2, tgt):
+    """Apply Toffoli to ctl1 and ctl2 to tgt."""
+    return self.append(ToffoliGate(), [ctl1, ctl2, tgt], [])
+
+
+QuantumCircuit.ccx = ccx
+QuantumCircuit.toffoli = ccx
diff --git a/qiskit/extensions/standard/y.py b/qiskit/extensions/standard/y.py
index 715c8701905d..37f2b9bd737f 100644
--- a/qiskit/extensions/standard/y.py
+++ b/qiskit/extensions/standard/y.py
@@ -17,10 +17,10 @@
 """
 import numpy
 from qiskit.circuit import Gate
+from qiskit.circuit import ControlledGate
 from qiskit.circuit import QuantumRegister
 from qiskit.circuit import QuantumCircuit
 from qiskit.qasm import pi
-from qiskit.extensions.standard.u3 import U3Gate
 
 
 class YGate(Gate):
@@ -31,6 +31,7 @@ def __init__(self, label=None):
         super().__init__("y", 1, [], label=label)
 
     def _define(self):
+        from qiskit.extensions.standard.u3 import U3Gate
         definition = []
         q = QuantumRegister(1, "q")
         rule = [
@@ -40,6 +41,20 @@ def _define(self):
             definition.append(inst)
         self.definition = definition
 
+    def control(self, num_ctrl_qubits=1, label=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]
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if num_ctrl_qubits == 1:
+            return CyGate()
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label)
+
     def inverse(self):
         """Invert this gate."""
         return YGate()  # self-inverse
@@ -56,3 +71,43 @@ def y(self, q):
 
 
 QuantumCircuit.y = y
+
+
+class CyGate(ControlledGate):
+    """controlled-Y gate."""
+
+    def __init__(self):
+        """Create new CY gate."""
+        super().__init__("cy", 2, [], num_ctrl_qubits=1)
+        self.base_gate = YGate
+        self.base_gate_name = "y"
+
+    def _define(self):
+        """
+        gate cy a,b { sdg b; cx a,b; s b; }
+        """
+        from qiskit.extensions.standard.s import SGate
+        from qiskit.extensions.standard.s import SdgGate
+        from qiskit.extensions.standard.x import CnotGate
+        definition = []
+        q = QuantumRegister(2, "q")
+        rule = [
+            (SdgGate(), [q[1]], []),
+            (CnotGate(), [q[0], q[1]], []),
+            (SGate(), [q[1]], [])
+        ]
+        for inst in rule:
+            definition.append(inst)
+        self.definition = definition
+
+    def inverse(self):
+        """Invert this gate."""
+        return CyGate()  # self-inverse
+
+
+def cy(self, ctl, tgt):  # pylint: disable=invalid-name
+    """Apply CY to circuit."""
+    return self.append(CyGate(), [ctl, tgt], [])
+
+
+QuantumCircuit.cy = cy
diff --git a/qiskit/extensions/standard/z.py b/qiskit/extensions/standard/z.py
index e652a369fceb..f80804250baa 100644
--- a/qiskit/extensions/standard/z.py
+++ b/qiskit/extensions/standard/z.py
@@ -17,10 +17,10 @@
 """
 import numpy
 from qiskit.circuit import Gate
+from qiskit.circuit import ControlledGate
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister
 from qiskit.qasm import pi
-from qiskit.extensions.standard.u1 import U1Gate
 
 
 class ZGate(Gate):
@@ -31,6 +31,7 @@ def __init__(self, label=None):
         super().__init__("z", 1, [], label=label)
 
     def _define(self):
+        from qiskit.extensions.standard.u1 import U1Gate
         definition = []
         q = QuantumRegister(1, "q")
         rule = [
@@ -40,6 +41,20 @@ def _define(self):
             definition.append(inst)
         self.definition = definition
 
+    def control(self, num_ctrl_qubits=1, label=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]
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if num_ctrl_qubits == 1:
+            return CzGate()
+        return super().control(num_ctrl_qubits=num_ctrl_qubits, label=label)
+
     def inverse(self):
         """Invert this gate."""
         return ZGate()  # self-inverse
@@ -56,3 +71,49 @@ def z(self, q):
 
 
 QuantumCircuit.z = z
+
+
+class CzGate(ControlledGate):
+    """controlled-Z gate."""
+
+    def __init__(self, label=None):
+        """Create new CZ gate."""
+        super().__init__("cz", 2, [], label=label, num_ctrl_qubits=1)
+        self.base_gate = ZGate
+        self.base_gate_name = "z"
+
+    def _define(self):
+        """
+        gate cz a,b { h b; cx a,b; h b; }
+        """
+        from qiskit.extensions.standard.h import HGate
+        from qiskit.extensions.standard.x import CnotGate
+        definition = []
+        q = QuantumRegister(2, "q")
+        rule = [
+            (HGate(), [q[1]], []),
+            (CnotGate(), [q[0], q[1]], []),
+            (HGate(), [q[1]], [])
+        ]
+        for inst in rule:
+            definition.append(inst)
+        self.definition = definition
+
+    def inverse(self):
+        """Invert this gate."""
+        return CzGate()  # self-inverse
+
+    def to_matrix(self):
+        """Return a Numpy.array for the Cz gate."""
+        return numpy.array([[1, 0, 0, 0],
+                            [0, 1, 0, 0],
+                            [0, 0, 1, 0],
+                            [0, 0, 0, -1]], dtype=complex)
+
+
+def cz(self, ctl, tgt):  # pylint: disable=invalid-name
+    """Apply CZ to circuit."""
+    return self.append(CzGate(), [ctl, tgt], [])
+
+
+QuantumCircuit.cz = cz
diff --git a/qiskit/quantum_info/synthesis/two_qubit_decompose.py b/qiskit/quantum_info/synthesis/two_qubit_decompose.py
index 770e2faec10f..a921d9addad3 100644
--- a/qiskit/quantum_info/synthesis/two_qubit_decompose.py
+++ b/qiskit/quantum_info/synthesis/two_qubit_decompose.py
@@ -34,7 +34,7 @@
 from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.extensions.standard.u3 import U3Gate
-from qiskit.extensions.standard.cx import CnotGate
+from qiskit.extensions.standard.x import CnotGate
 from qiskit.exceptions import QiskitError
 from qiskit.quantum_info.operators.predicates import is_unitary_matrix
 from qiskit.quantum_info.synthesis.weyl import weyl_coordinates
diff --git a/qiskit/transpiler/passes/utils/check_cx_direction.py b/qiskit/transpiler/passes/utils/check_cx_direction.py
index 2c068bc67d15..edcfbf31649b 100644
--- a/qiskit/transpiler/passes/utils/check_cx_direction.py
+++ b/qiskit/transpiler/passes/utils/check_cx_direction.py
@@ -15,7 +15,7 @@
 """Check if the CNOTs follow the right direction with respect to the coupling map."""
 
 from qiskit.transpiler.basepasses import AnalysisPass
-from qiskit.extensions.standard.cx import CnotGate
+from qiskit.extensions.standard.x import CnotGate
 
 
 class CheckCXDirection(AnalysisPass):
diff --git a/test/python/circuit/test_controlled_gate.py b/test/python/circuit/test_controlled_gate.py
index f6328ca1ec11..06b25048c758 100644
--- a/test/python/circuit/test_controlled_gate.py
+++ b/test/python/circuit/test_controlled_gate.py
@@ -169,7 +169,6 @@ def test_single_controlled_composite_gate(self):
     def test_multi_control_u3(self):
         """test multi controlled u3 gate"""
         import qiskit.extensions.standard.u3 as u3
-        import qiskit.extensions.standard.cu3 as cu3
 
         num_ctrl = 3
         # U3 gate params
@@ -195,7 +194,7 @@ def test_multi_control_u3(self):
         width = 3
         qr = QuantumRegister(width)
         qc_cu3 = QuantumCircuit(qr)
-        cu3gate = cu3.Cu3Gate(alpha, beta, gamma)
+        cu3gate = u3.Cu3Gate(alpha, beta, gamma)
 
         c_cu3 = cu3gate.control(1)
         qc_cu3.append(c_cu3, qr, [])
@@ -231,7 +230,6 @@ def test_multi_control_u3(self):
     def test_multi_control_u1(self):
         """Test multi controlled u1 gate"""
         import qiskit.extensions.standard.u1 as u1
-        import qiskit.extensions.standard.cu1 as cu1
 
         num_ctrl = 3
         # U1 gate params
@@ -257,7 +255,7 @@ def test_multi_control_u1(self):
         width = 3
         qr = QuantumRegister(width)
         qc_cu1 = QuantumCircuit(qr)
-        cu1gate = cu1.Cu1Gate(theta)
+        cu1gate = u1.Cu1Gate(theta)
         c_cu1 = cu1gate.control(1)
         qc_cu1.append(c_cu1, qr, [])
 
@@ -300,7 +298,7 @@ def test_rotation_gates(self):
         num_target = 1
         qreg = QuantumRegister(num_ctrl + num_target)
 
-        theta = pi
+        theta = pi/2
         gu1 = u1.U1Gate(theta)
         grx = rx.RXGate(theta)
         gry = ry.RYGate(theta)
diff --git a/test/python/circuit/test_instructions.py b/test/python/circuit/test_instructions.py
index 0496ed0f9641..4be158ef2de2 100644
--- a/test/python/circuit/test_instructions.py
+++ b/test/python/circuit/test_instructions.py
@@ -24,7 +24,7 @@
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit import QuantumRegister, ClassicalRegister
 from qiskit.extensions.standard.h import HGate
-from qiskit.extensions.standard.cx import CnotGate
+from qiskit.extensions.standard.x import CnotGate
 from qiskit.extensions.standard.s import SGate
 from qiskit.extensions.standard.t import TGate
 from qiskit.test import QiskitTestCase
diff --git a/test/python/pickles/TestsBasicSwap_a_cx_to_map.pickle b/test/python/pickles/TestsBasicSwap_a_cx_to_map.pickle
index 5f84f6014afd..f1f500be8ab8 100644
Binary files a/test/python/pickles/TestsBasicSwap_a_cx_to_map.pickle and b/test/python/pickles/TestsBasicSwap_a_cx_to_map.pickle differ
diff --git a/test/python/pickles/TestsBasicSwap_handle_measurement.pickle b/test/python/pickles/TestsBasicSwap_handle_measurement.pickle
index 7f41eee757bd..cbf9c1b23ec7 100644
Binary files a/test/python/pickles/TestsBasicSwap_handle_measurement.pickle and b/test/python/pickles/TestsBasicSwap_handle_measurement.pickle differ
diff --git a/test/python/pickles/TestsBasicSwap_initial_layout.pickle b/test/python/pickles/TestsBasicSwap_initial_layout.pickle
index 63beaa46f52a..52d25865490a 100644
Binary files a/test/python/pickles/TestsBasicSwap_initial_layout.pickle and b/test/python/pickles/TestsBasicSwap_initial_layout.pickle differ
diff --git a/test/python/pickles/TestsLookaheadSwap_a_cx_to_map.pickle b/test/python/pickles/TestsLookaheadSwap_a_cx_to_map.pickle
index e251e8725f70..db94985c8e5f 100644
Binary files a/test/python/pickles/TestsLookaheadSwap_a_cx_to_map.pickle and b/test/python/pickles/TestsLookaheadSwap_a_cx_to_map.pickle differ
diff --git a/test/python/pickles/TestsLookaheadSwap_handle_measurement.pickle b/test/python/pickles/TestsLookaheadSwap_handle_measurement.pickle
index 898bbad7dd61..9dbdd21b4af7 100644
Binary files a/test/python/pickles/TestsLookaheadSwap_handle_measurement.pickle and b/test/python/pickles/TestsLookaheadSwap_handle_measurement.pickle differ
diff --git a/test/python/pickles/TestsLookaheadSwap_initial_layout.pickle b/test/python/pickles/TestsLookaheadSwap_initial_layout.pickle
index 8d7e4dea586d..ff51f17c577b 100644
Binary files a/test/python/pickles/TestsLookaheadSwap_initial_layout.pickle and b/test/python/pickles/TestsLookaheadSwap_initial_layout.pickle differ
diff --git a/test/python/pickles/TestsStochasticSwap_a_cx_to_map.pickle b/test/python/pickles/TestsStochasticSwap_a_cx_to_map.pickle
index 8414736eac1a..1d03fe66f1b6 100644
Binary files a/test/python/pickles/TestsStochasticSwap_a_cx_to_map.pickle and b/test/python/pickles/TestsStochasticSwap_a_cx_to_map.pickle differ
diff --git a/test/python/pickles/TestsStochasticSwap_handle_measurement.pickle b/test/python/pickles/TestsStochasticSwap_handle_measurement.pickle
index 04c4b356c0a3..550f23387f74 100644
Binary files a/test/python/pickles/TestsStochasticSwap_handle_measurement.pickle and b/test/python/pickles/TestsStochasticSwap_handle_measurement.pickle differ
diff --git a/test/python/pickles/TestsStochasticSwap_initial_layout.pickle b/test/python/pickles/TestsStochasticSwap_initial_layout.pickle
index 9b1931e9249b..c5c34acda5c3 100644
Binary files a/test/python/pickles/TestsStochasticSwap_initial_layout.pickle and b/test/python/pickles/TestsStochasticSwap_initial_layout.pickle differ
diff --git a/test/python/test_dagcircuit.py b/test/python/test_dagcircuit.py
index 08b47c384f6e..76fb01ac7f0c 100644
--- a/test/python/test_dagcircuit.py
+++ b/test/python/test_dagcircuit.py
@@ -29,8 +29,8 @@
 from qiskit.circuit import Gate, Instruction
 from qiskit.extensions.standard.iden import IdGate
 from qiskit.extensions.standard.h import HGate
-from qiskit.extensions.standard.cx import CnotGate
-from qiskit.extensions.standard.cz import CzGate
+from qiskit.extensions.standard.x import CnotGate
+from qiskit.extensions.standard.z import CzGate
 from qiskit.extensions.standard.x import XGate
 from qiskit.extensions.standard.u1 import U1Gate
 from qiskit.extensions.standard.barrier import Barrier