Support phase gates in LitinskiTransformation

crates/transpiler/src/passes/litinski_transformation.rs

@@ -17,7 +17,7 @@ use qiskit_circuit::imports::PAULI_EVOLUTION_GATE;
 use qiskit_circuit::instruction::Parameters;
 use qiskit_circuit::operations::{
     Operation, OperationRef, Param, PauliBased, PauliProductMeasurement, PauliProductRotation,
-    PyInstruction, PyOperationTypes, StandardGate, StandardInstruction, multiply_param,
+    PyInstruction, PyOperationTypes, StandardGate, StandardInstruction, multiply_param, radd_param,
 };
 use qiskit_circuit::packed_instruction::PackedInstruction;
 use qiskit_circuit::{BlocksMode, Qubit, VarsMode};
@@ -28,18 +28,18 @@ use qiskit_quantum_info::clifford::Clifford;
 use qiskit_quantum_info::sparse_observable::{BitTerm, SparseObservable};
 
 use smallvec::smallvec;
-use std::f64::consts::PI;
+use std::f64::consts::{FRAC_PI_4, FRAC_PI_8};
 
 // List of gate/instruction names supported by the pass: the pass raises an error if the circuit
 // contains instruction with names outside of this list.
-static SUPPORTED_INSTRUCTION_NAMES: [&str; 20] = [
+static SUPPORTED_INSTRUCTION_NAMES: [&str; 22] = [
     "id", "x", "y", "z", "h", "s", "sdg", "sx", "sxdg", "cx", "cz", "cy", "swap", "iswap", "ecr",
-    "dcx", "t", "tdg", "rz", "measure",
+    "dcx", "t", "tdg", "rz", "p", "u1", "measure",
 ];
 
 // List of instruction names which are modified by the pass: the pass is skipped if the circuit
 // contains no instructions with names in this list.
-static HANDLED_INSTRUCTION_NAMES: [&str; 4] = ["t", "tdg", "rz", "measure"];
+static HANDLED_INSTRUCTION_NAMES: [&str; 6] = ["t", "tdg", "rz", "p", "u1", "measure"];
 
 #[pyfunction]
 #[pyo3(signature = (dag, fix_clifford=true, insert_barrier=false, use_ppr=false))]
@@ -88,7 +88,7 @@ pub fn run_litinski_transformation(
 
     // Keep track of the update to the global phase (produced when converting T/Tdg gates
     // to RZ-rotations).
-    let mut global_phase_update = 0.;
+    let mut global_phase_update = Param::Float(0.);
 
     // Keep track of the clifford operations in the circuit.
     let mut clifford_ops: Vec<&PackedInstruction> = Vec::with_capacity(clifford_count);
@@ -218,24 +218,33 @@ pub fn run_litinski_transformation(
                 }
                 OperationRef::StandardGate(StandardGate::T)
                 | OperationRef::StandardGate(StandardGate::Tdg)
-                | OperationRef::StandardGate(StandardGate::RZ) => {
+                | OperationRef::StandardGate(StandardGate::RZ)
+                | OperationRef::StandardGate(StandardGate::Phase)
+                | OperationRef::StandardGate(StandardGate::U1) => {
                     // Convert T and Tdg gates to RZ rotations
                     let (angle, phase_update) = match inst.op.view() {
                         OperationRef::StandardGate(StandardGate::T) => {
-                            (Param::Float(PI / 4.), PI / 8.)
+                            (Param::Float(FRAC_PI_4), Param::Float(FRAC_PI_8))
                         }
                         OperationRef::StandardGate(StandardGate::Tdg) => {
-                            (Param::Float(-PI / 4.0), -PI / 8.)
+                            (Param::Float(-FRAC_PI_4), Param::Float(-FRAC_PI_8))
                         }
                         OperationRef::StandardGate(StandardGate::RZ) => {
                             let param = &inst.params_view()[0];
-                            (param.clone(), 0.)
+                            (param.clone(), Param::Float(0.))
+                        }
+                        OperationRef::StandardGate(StandardGate::Phase)
+                        | OperationRef::StandardGate(StandardGate::U1) => {
+                            let param = &inst.params_view()[0];
+                            (param.clone(), multiply_param(param, 0.5))
                         }
                         _ => {
-                            unreachable!("We cannot have gates other than T/Tdg/RZ at this point.");
+                            unreachable!(
+                                "We cannot have gates other than T/Tdg/RZ/P/U1 at this point."
+                            );
                         }
                     };
-                    global_phase_update += phase_update;
+                    global_phase_update = radd_param(global_phase_update, phase_update);
 
                     // Evolve the single-qubit Pauli-Z with Z on the given qubit.
                     // Returns the evolved Pauli in the sparse format: (sign, pauli z, pauli x, indices),
@@ -317,7 +326,7 @@ pub fn run_litinski_transformation(
         }
     }
 
-    new_dag.add_global_phase(&Param::Float(global_phase_update))?;
+    new_dag.add_global_phase(&global_phase_update)?;
 
     // Add Clifford gates to the Qiskit circuit (when required).
     // Since we aim to preserve the global phase of the circuit, we add the Clifford operations from

qiskit/transpiler/passes/optimization/litinski_transformation.py

@@ -34,7 +34,7 @@ class LitinskiTransformation(TransformationPass):
 
     The list of supported :math:`R_Z`-rotations is:
 
-    ``["t", "tdg", "rz"]``
+    ``["t", "tdg", "rz", "p", "u1"]``
 
     Example:
 

releasenotes/notes/litinski-phase-gate-197b06e529a53c64.yaml

@@ -0,0 +1,5 @@
+---
+features_transpiler:
+  - The :class:`.LitinskiTransformation` now also supports circuits with
+    :class:`.PhaseGate` and :class:`.U1Gate` instructions. Previously, the only
+    accepted parameterized gate was :class:`.RZGate`.

test/python/transpiler/test_litinski_transformation.py

@@ -22,6 +22,7 @@
     PauliEvolutionGate,
     PauliProductMeasurement,
     PauliProductRotationGate,
+    U1Gate,
 )
 from qiskit.circuit.random import random_clifford_circuit
 from qiskit.compiler import transpile
@@ -179,14 +180,15 @@ def test_all_supported_clifford_gates(self):
         qc.rz(0.1, 1)
         qc.tdg(2)
         qc.rz(-0.2, 3)
+        qc.p(0.3, 0)
+        qc.append(U1Gate(-0.5), [0])
 
         qc_litinski = LitinskiTransformation()(qc)
         ops_litinski = qc_litinski.count_ops()
 
         # make sure the transform was applied
-        self.assertNotIn("t", ops_litinski)
-        self.assertNotIn("tdg", ops_litinski)
-        self.assertNotIn("rz", ops_litinski)
+        for z_rot in ["t", "tdg", "rz", "p", "u1"]:
+            self.assertNotIn(z_rot, ops_litinski)
 
         # make sure the result is correct
         self.assertEqual(Operator(qc_litinski), Operator(qc))
@@ -254,6 +256,19 @@ def test_tdg(self):
 
         self.assertEqual(qct, expected)
 
+    def test_p(self):
+        """Test the phase gate, ensuring we got the global phase right."""
+        angle = 0.231
+        qc = QuantumCircuit(1)
+        qc.p(angle, 0)
+
+        qct = LitinskiTransformation(use_ppr=True)(qc)
+        self.assertTrue(np.allclose(Operator(qc).data, Operator(qct).data))
+
+        expected = QuantumCircuit(1, global_phase=angle / 2)
+        expected.append(PauliProductRotationGate(Pauli("Z"), angle), [0])
+        self.assertEqual(qct, expected)
+
     def test_h_t(self):
         """Test the transform on a circuit with an H-gate and a T-gate."""
         qc = QuantumCircuit(2)