Porting synth_c3x to Rust

This is the beginning of porting of (some) of the MCX synthesis methods to Rust.
Here it also serves as a very simple example of using SynthesisData.

Author: alexanderivrii

crates/accelerate/src/synthesis/common/mod.rs

@@ -122,23 +122,40 @@ impl<'a> SynthesisData<'a> {
     }
 
     // Convenience functions
+
+    /// Appends XGate to the circuit.
     #[inline]
     pub fn x(&mut self, q: u32) {
         self.push_standard_gate(StandardGate::XGate, &[], &[q]);
     }
 
+    /// Appends HGate to the circuit.
     #[inline]
     pub fn h(&mut self, q: u32) {
         self.push_standard_gate(StandardGate::HGate, &[], &[q]);
     }
 
+    /// Appends TGate to the circuit.
     #[inline]
     pub fn t(&mut self, q: u32) {
         self.push_standard_gate(StandardGate::TGate, &[], &[q]);
     }
 
+    /// Appends TdgGate to the circuit.
     #[inline]
     pub fn tdg(&mut self, q: u32) {
         self.push_standard_gate(StandardGate::TdgGate, &[], &[q]);
     }
+
+    /// Appends PhaseGate to the circuit.
+    #[inline]
+    pub fn p(&mut self, theta: f64, q: u32) {
+        self.push_standard_gate(StandardGate::PhaseGate, &[Param::Float(theta)], &[q]);
+    }
+
+    /// Appends CXGate to the circuit.
+    #[inline]
+    pub fn cx(&mut self, q1: u32, q2: u32) {
+        self.push_standard_gate(StandardGate::CXGate, &[], &[q1, q2]);
+    }
 }

crates/accelerate/src/synthesis/multi_controlled/mcx.rs

@@ -0,0 +1,56 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2025
+//
+// This code is licensed under the Apache License, Version 2.0. You may
+// obtain a copy of this license in the LICENSE.txt file in the root directory
+// of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+//
+// Any modifications or derivative works of this code must retain this
+// copyright notice, and modified files need to carry a notice indicating
+// that they have been altered from the originals.
+
+use crate::synthesis::common::SynthesisData;
+
+use std::f64::consts::PI;
+
+// const PI2: f64 = PI / 2.;
+// const PI4: f64 = PI / 4.;
+const PI8: f64 = PI / 8.;
+
+/// Efficient synthesis for 3-controlled X-gate.
+pub fn c3x<'a>() -> SynthesisData<'a> {
+    let mut qc = SynthesisData::new(4);
+    qc.h(3);
+    qc.p(PI8, 0);
+    qc.p(PI8, 1);
+    qc.p(PI8, 2);
+    qc.p(PI8, 3);
+    qc.cx(0, 1);
+    qc.p(-PI8, 1);
+    qc.cx(0, 1);
+    qc.cx(1, 2);
+    qc.p(-PI8, 2);
+    qc.cx(0, 2);
+    qc.p(PI8, 2);
+    qc.cx(1, 2);
+    qc.p(-PI8, 2);
+    qc.cx(0, 2);
+    qc.cx(2, 3);
+    qc.p(-PI8, 3);
+    qc.cx(1, 3);
+    qc.p(PI8, 3);
+    qc.cx(2, 3);
+    qc.p(-PI8, 3);
+    qc.cx(0, 3);
+    qc.p(PI8, 3);
+    qc.cx(2, 3);
+    qc.p(-PI8, 3);
+    qc.cx(1, 3);
+    qc.p(PI8, 3);
+    qc.cx(2, 3);
+    qc.p(-PI8, 3);
+    qc.cx(0, 3);
+    qc.h(3);
+    qc
+}

crates/accelerate/src/synthesis/multi_controlled/mod.rs

@@ -10,11 +10,20 @@
 // copyright notice, and modified files need to carry a notice indicating
 // that they have been altered from the originals.
 
+use mcx::c3x;
 use pyo3::prelude::*;
+use qiskit_circuit::circuit_data::CircuitData;
 
 mod mcmt;
+mod mcx;
+
+#[pyfunction]
+pub fn py_c3x(py: Python) -> PyResult<CircuitData> {
+    c3x().to_circuit_data(py)
+}
 
 pub fn multi_controlled(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(py_c3x, m)?)?;
     m.add_function(wrap_pyfunction!(mcmt::mcmt_v_chain, m)?)?;
     Ok(())
 }

qiskit/synthesis/multi_controlled/mcx_synthesis.py

@@ -25,6 +25,8 @@
     C3SXGate,
 )
 
+from qiskit._accelerate.synthesis.multi_controlled import py_c3x
+
 
 def synth_mcx_n_dirty_i15(
     num_ctrl_qubits: int,
@@ -302,38 +304,8 @@ def synth_mcx_noaux_v24(num_ctrl_qubits: int) -> QuantumCircuit:
 
 def synth_c3x() -> QuantumCircuit:
     """Efficient synthesis of 3-controlled X-gate."""
-
-    q = QuantumRegister(4, name="q")
-    qc = QuantumCircuit(q, name="mcx")
-    qc.h(3)
-    qc.p(np.pi / 8, [0, 1, 2, 3])
-    qc.cx(0, 1)
-    qc.p(-np.pi / 8, 1)
-    qc.cx(0, 1)
-    qc.cx(1, 2)
-    qc.p(-np.pi / 8, 2)
-    qc.cx(0, 2)
-    qc.p(np.pi / 8, 2)
-    qc.cx(1, 2)
-    qc.p(-np.pi / 8, 2)
-    qc.cx(0, 2)
-    qc.cx(2, 3)
-    qc.p(-np.pi / 8, 3)
-    qc.cx(1, 3)
-    qc.p(np.pi / 8, 3)
-    qc.cx(2, 3)
-    qc.p(-np.pi / 8, 3)
-    qc.cx(0, 3)
-    qc.p(np.pi / 8, 3)
-    qc.cx(2, 3)
-    qc.p(-np.pi / 8, 3)
-    qc.cx(1, 3)
-    qc.p(np.pi / 8, 3)
-    qc.cx(2, 3)
-    qc.p(-np.pi / 8, 3)
-    qc.cx(0, 3)
-    qc.h(3)
-    return qc
+    circ = QuantumCircuit._from_circuit_data(py_c3x())
+    return circ
 
 
 def synth_c4x() -> QuantumCircuit:

test/python/synthesis/test_mcx_synthesis.py

@@ -0,0 +1,34 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2025.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Test MCX synthesis."""
+
+import unittest
+
+from qiskit.quantum_info import Operator
+from qiskit.circuit.library import C3XGate
+from qiskit.synthesis.multi_controlled import synth_c3x
+
+from test import QiskitTestCase  # pylint: disable=wrong-import-order
+
+
+class TestMCXSynth(QiskitTestCase):
+    """Test MCX synthesis methods."""
+
+    def test_c3x(self):
+        """Test the default synthesis method for C3XGate."""
+        # ToDo: it might be nicer to compare with the actual matrix
+        self.assertEqual(Operator(C3XGate().definition), Operator(synth_c3x()))
+
+
+if __name__ == "__main__":
+    unittest.main()