Add simplify of U3->U1/U2 in OneQubitEulerDecomposer

qiskit/quantum_info/synthesis/one_qubit_decompose.py

@@ -20,15 +20,17 @@
 import scipy.linalg as la
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.library.standard_gates import (PhaseGate, U3Gate,
-                                                   U1Gate, RXGate, RYGate,
+from qiskit.circuit.library.standard_gates import (UGate, PhaseGate, U3Gate,
+                                                   U2Gate, U1Gate, RXGate, RYGate,
                                                    RZGate, RGate, SXGate)
 from qiskit.exceptions import QiskitError
 from qiskit.quantum_info.operators.predicates import is_unitary_matrix
 
 DEFAULT_ATOL = 1e-12
 
 ONE_QUBIT_EULER_BASIS_GATES = {
+    # 'U321' must precede 'U3' in the list
+    'U321': ['u3', 'u2', 'u1'],
     'U3': ['u3'],
     'U': ['u'],
     'PSX': ['p', 'sx'],
@@ -156,6 +158,7 @@ def basis(self):
     def basis(self, basis):
         """Set the decomposition basis."""
         basis_methods = {
+            'U321': (self._params_u3, self._circuit_u321),
             'U3': (self._params_u3, self._circuit_u3),
             'U': (self._params_u3, self._circuit_u),
             'PSX': (self._params_u1x, self._circuit_psx),
@@ -281,13 +284,12 @@ def _circuit_zxz(theta,
                      phi,
                      lam,
                      phase,
-                     simplify=False,
+                     simplify=True,
                      atol=DEFAULT_ATOL):
+        circuit = QuantumCircuit(1, global_phase=phase)
         if simplify and np.isclose(theta, 0.0, atol=atol):
-            circuit = QuantumCircuit(1, global_phase=phase)
             circuit.append(RZGate(phi + lam), [0])
             return circuit
-        circuit = QuantumCircuit(1, global_phase=phase)
         if not simplify or not np.isclose(lam, 0.0, atol=atol):
             circuit.append(RZGate(lam), [0])
         if not simplify or not np.isclose(theta, 0.0, atol=atol):
@@ -327,6 +329,23 @@ def _circuit_u3(theta,
         circuit.append(U3Gate(theta, phi, lam), [0])
         return circuit
 
+    @staticmethod
+    def _circuit_u321(theta,
+                      phi,
+                      lam,
+                      phase,
+                      simplify=True,
+                      atol=DEFAULT_ATOL):
+        circuit = QuantumCircuit(1, global_phase=phase)
+        if simplify and (np.isclose(theta, 0.0, atol=atol)):
+            if not np.isclose(phi+lam, [0.0, 2*np.pi], atol=atol).any():
+                circuit.append(U1Gate(_mod2pi(phi+lam)), [0])
+        elif simplify and np.isclose(abs(theta), np.pi/2, atol=atol):
+            circuit.append(U2Gate(phi, lam), [0])
+        else:
+            circuit.append(U3Gate(theta, phi, lam), [0])
+        return circuit
+
     @staticmethod
     def _circuit_u(theta,
                    phi,
@@ -336,7 +355,7 @@ def _circuit_u(theta,
                    atol=DEFAULT_ATOL):
         # pylint: disable=unused-argument
         circuit = QuantumCircuit(1, global_phase=phase)
-        circuit.u(theta, phi, lam, 0)
+        circuit.append(UGate(theta, phi, lam), [0])
         return circuit
 
     @staticmethod

qiskit/transpiler/preset_passmanagers/level1.py

@@ -40,7 +40,6 @@
 from qiskit.transpiler.passes import FixedPoint
 from qiskit.transpiler.passes import Depth
 from qiskit.transpiler.passes import RemoveResetInZeroState
-from qiskit.transpiler.passes import Optimize1qGates
 from qiskit.transpiler.passes import Optimize1qGatesDecomposition
 from qiskit.transpiler.passes import ApplyLayout
 from qiskit.transpiler.passes import CheckCXDirection
@@ -179,11 +178,7 @@ def _direction_condition(property_set):
     def _opt_control(property_set):
         return not property_set['depth_fixed_point']
 
-    if basis_gates and ('u1' in basis_gates or 'u2' in basis_gates or
-                        'u3' in basis_gates):
-        _opt = [Optimize1qGates(basis_gates), CXCancellation()]
-    else:
-        _opt = [Optimize1qGatesDecomposition(basis_gates), CXCancellation()]
+    _opt = [Optimize1qGatesDecomposition(basis_gates), CXCancellation()]
 
     # 10. Schedule the circuit only when scheduling_method is supplied
     if scheduling_method:

qiskit/transpiler/preset_passmanagers/level2.py

@@ -41,7 +41,6 @@
 from qiskit.transpiler.passes import FixedPoint
 from qiskit.transpiler.passes import Depth
 from qiskit.transpiler.passes import RemoveResetInZeroState
-from qiskit.transpiler.passes import Optimize1qGates
 from qiskit.transpiler.passes import Optimize1qGatesDecomposition
 from qiskit.transpiler.passes import CommutativeCancellation
 from qiskit.transpiler.passes import ApplyLayout
@@ -175,11 +174,7 @@ def _direction_condition(property_set):
     def _opt_control(property_set):
         return not property_set['depth_fixed_point']
 
-    if basis_gates and ('u1' in basis_gates or 'u2' in basis_gates or
-                        'u3' in basis_gates):
-        _opt = [Optimize1qGates(basis_gates), CommutativeCancellation()]
-    else:
-        _opt = [Optimize1qGatesDecomposition(basis_gates), CommutativeCancellation()]
+    _opt = [Optimize1qGatesDecomposition(basis_gates), CommutativeCancellation()]
 
     # 9. Schedule the circuit only when scheduling_method is supplied
     if scheduling_method:

qiskit/transpiler/preset_passmanagers/level3.py

@@ -42,7 +42,6 @@
 from qiskit.transpiler.passes import FixedPoint
 from qiskit.transpiler.passes import Depth
 from qiskit.transpiler.passes import RemoveResetInZeroState
-from qiskit.transpiler.passes import Optimize1qGates
 from qiskit.transpiler.passes import Optimize1qGatesDecomposition
 from qiskit.transpiler.passes import CommutativeCancellation
 from qiskit.transpiler.passes import OptimizeSwapBeforeMeasure
@@ -180,23 +179,13 @@ def _opt_control(property_set):
 
     _meas = [OptimizeSwapBeforeMeasure(), RemoveDiagonalGatesBeforeMeasure()]
 
-    if basis_gates and ('u1' in basis_gates or 'u2' in basis_gates or
-                        'u3' in basis_gates):
-        _opt = [
-            Collect2qBlocks(),
-            ConsolidateBlocks(basis_gates=basis_gates),
-            UnitarySynthesis(basis_gates),
-            Optimize1qGates(basis_gates),
-            CommutativeCancellation(),
-        ]
-    else:
-        _opt = [
-            Collect2qBlocks(),
-            ConsolidateBlocks(basis_gates=basis_gates),
-            UnitarySynthesis(basis_gates),
-            Optimize1qGatesDecomposition(basis_gates),
-            CommutativeCancellation(),
-        ]
+    _opt = [
+        Collect2qBlocks(),
+        ConsolidateBlocks(basis_gates=basis_gates),
+        UnitarySynthesis(basis_gates),
+        Optimize1qGatesDecomposition(basis_gates),
+        CommutativeCancellation(),
+    ]
 
     # Schedule the circuit only when scheduling_method is supplied
     if scheduling_method:

test/python/circuit/test_isometry.py

@@ -28,18 +28,20 @@
 from qiskit.quantum_info import Operator
 from qiskit.extensions.quantum_initializer.isometry import Isometry
 
+SEED = 125
+
 
 @ddt
 class TestIsometry(QiskitTestCase):
     """Qiskit isometry tests."""
 
-    @data(np.eye(2, 2), random_unitary(2).data, np.eye(4, 4),
-          random_unitary(4).data[:, 0],
-          np.eye(4, 4)[:, 0:2], random_unitary(4).data,
+    @data(np.eye(2, 2), random_unitary(2, seed=SEED).data, np.eye(4, 4),
+          random_unitary(4, seed=SEED).data[:, 0],
+          np.eye(4, 4)[:, 0:2], random_unitary(4, seed=SEED).data,
           np.eye(4, 4)[:, np.random.permutation(np.eye(4, 4).shape[1])][:, 0:2],
           np.eye(8, 8)[:, np.random.permutation(np.eye(8, 8).shape[1])],
-          random_unitary(8).data[:, 0:4], random_unitary(8).data, random_unitary(16).data,
-          random_unitary(16).data[:, 0:8])
+          random_unitary(8, seed=SEED).data[:, 0:4], random_unitary(8, seed=SEED).data,
+          random_unitary(16, seed=SEED).data, random_unitary(16, seed=SEED).data[:, 0:8])
     def test_isometry(self, iso):
         """Tests for the decomposition of isometries from m to n qubits"""
         if len(iso.shape) == 1:
@@ -62,6 +64,7 @@ def test_isometry(self, iso):
         unitary = result.get_unitary(qc)
         iso_from_circuit = unitary[::, 0:2 ** num_q_input]
         iso_desired = iso
+
         self.assertTrue(matrix_equal(iso_from_circuit, iso_desired, ignore_phase=True))
 
     @data(np.eye(2, 2), random_unitary(2).data, np.eye(4, 4),

test/python/compiler/test_transpiler.py

@@ -536,9 +536,9 @@ def test_optimize_to_nothing(self):
         circ.cx(qr[0], qr[1])
 
         after = transpile(circ, coupling_map=[[0, 1], [1, 0]],
-                          basis_gates=['u3', 'cx'])
+                          basis_gates=['u3', 'u2', 'u1', 'cx'])
 
-        expected = QuantumCircuit(QuantumRegister(2, 'q'))
+        expected = QuantumCircuit(QuantumRegister(2, 'q'), global_phase=-np.pi/2)
         self.assertEqual(after, expected)
 
     def test_pass_manager_empty(self):

test/python/quantum_info/test_synthesis.py

@@ -533,7 +533,8 @@ def test_seed_289(self):
         self.check_exact_decomposition(unitary.data, two_qubit_cnot_decompose)
 
     @combine(seed=range(10),
-             euler_bases=[('U3', ['u3']), ('U', ['u']), ('U1X', ['u1', 'rx']), ('RR', ['r']),
+             euler_bases=[('U321', ['u3', 'u2', 'u1']), ('U3', ['u3']), ('U', ['u']),
+                          ('U1X', ['u1', 'rx']), ('RR', ['r']),
                           ('PSX', ['p', 'sx']), ('ZYZ', ['rz', 'ry']), ('ZXZ', ['rz', 'rx']),
                           ('XYX', ['rx', 'ry']), ('ZSX', ['rz', 'sx'])],
              kak_gates=[(CXGate(), 'cx'), (CZGate(), 'cz'), (iSwapGate(), 'iswap'),

test/python/transpiler/test_optimize_1q_decomposition.py

@@ -18,7 +18,8 @@
 import numpy as np
 
 from qiskit.circuit import QuantumRegister, QuantumCircuit, ClassicalRegister
-from qiskit.circuit.library.standard_gates import U3Gate
+from qiskit.circuit.library.standard_gates import UGate, SXGate, PhaseGate
+from qiskit.circuit.library.standard_gates import U3Gate, U2Gate, U1Gate
 from qiskit.circuit.random import random_circuit
 from qiskit.transpiler import PassManager
 from qiskit.transpiler.passes import Optimize1qGatesDecomposition
@@ -61,6 +62,7 @@ def test_optimize_h_gates_pass_manager(self, basis):
         passmanager.append(BasisTranslator(sel, basis))
         passmanager.append(Optimize1qGatesDecomposition(basis))
         result = passmanager.run(circuit)
+
         self.assertTrue(Operator(circuit).equiv(Operator(result)))
 
     @ddt.data(
@@ -344,6 +346,80 @@ def test_euler_decomposition_worse(self):
         # assert optimization pass doesn't use it.
         self.assertEqual(result, circuit)
 
+    def test_optimize_u_to_phase_gate(self):
+        """U(0, 0, pi/4) ->  p(pi/4). Basis [p, sx]."""
+        qr = QuantumRegister(2, 'qr')
+        circuit = QuantumCircuit(qr)
+        circuit.append(UGate(0, 0, np.pi / 4), [qr[0]])
+
+        expected = QuantumCircuit(qr)
+        expected.append(PhaseGate(np.pi / 4), [qr[0]])
+
+        basis = ['p', 'sx']
+        passmanager = PassManager()
+        passmanager.append(BasisTranslator(sel, basis))
+        passmanager.append(Optimize1qGatesDecomposition(basis))
+        result = passmanager.run(circuit)
+
+        self.assertEqual(expected, result)
+
+    def test_optimize_u_to_p_sx_p(self):
+        """U(pi/2, 0, pi/4) ->  p(-pi/4)-sx-p(p/2). Basis [p, sx, cx]."""
+        qr = QuantumRegister(2, 'qr')
+        circuit = QuantumCircuit(qr)
+        circuit.append(UGate(np.pi / 2, 0, np.pi / 4), [qr[0]])
+        circuit.cx(0, 1)
+
+        expected = QuantumCircuit(qr, global_phase=-np.pi/4)
+        expected.append(PhaseGate(-np.pi / 4), [qr[0]])
+        expected.append(SXGate(), [qr[0]])
+        expected.append(PhaseGate(np.pi / 2), [qr[0]])
+        expected.cx(0, 1)
+
+        basis = ['p', 'sx', 'cx']
+        passmanager = PassManager()
+        passmanager.append(BasisTranslator(sel, basis))
+        passmanager.append(Optimize1qGatesDecomposition(basis))
+        result = passmanager.run(circuit)
+
+        self.assertEqual(expected, result)
+
+    def test_optimize_u3_to_u1(self):
+        """U3(0, 0, pi/4) ->  U1(pi/4). Basis [u1, u2, u3]."""
+        qr = QuantumRegister(2, 'qr')
+        circuit = QuantumCircuit(qr)
+        circuit.append(U3Gate(0, 0, np.pi / 4), [qr[0]])
+        circuit.append(U3Gate(0, 0, np.pi / 2), [qr[0]])
+
+        expected = QuantumCircuit(qr)
+        expected.append(U1Gate(3 * np.pi / 4), [qr[0]])
+
+        basis = ['u1', 'u2', 'u3']
+        passmanager = PassManager()
+        passmanager.append(BasisTranslator(sel, basis))
+        passmanager.append(Optimize1qGatesDecomposition(basis))
+        result = passmanager.run(circuit)
+
+        self.assertEqual(expected, result)
+
+    def test_optimize_u3_to_u2(self):
+        """U3(pi/2, 0, pi/4) ->  U2(0, pi/4). Basis [u1, u2, u3]."""
+        qr = QuantumRegister(2, 'qr')
+        circuit = QuantumCircuit(qr)
+        circuit.append(U3Gate(np.pi / 2, 0, np.pi / 4), [qr[0]])
+        circuit.append(U3Gate(0, 0, np.pi / 4), [qr[0]])
+
+        expected = QuantumCircuit(qr)
+        expected.append(U2Gate(np.pi / 4, np.pi / 4), [qr[0]])
+
+        basis = ['u1', 'u2', 'u3']
+        passmanager = PassManager()
+        passmanager.append(BasisTranslator(sel, basis))
+        passmanager.append(Optimize1qGatesDecomposition(basis))
+        result = passmanager.run(circuit)
+
+        self.assertEqual(expected, result)
+
 
 if __name__ == '__main__':
     unittest.main()