Merge branch 'main' into move-target

constraints.txt

@@ -3,6 +3,10 @@
 # https://github.com/Qiskit/qiskit-terra/issues/10345 for current details.
 scipy<1.11; python_version<'3.12'
 
+# Temporary pin to avoid CI issues caused by scipy 1.14.0
+# See https://github.com/Qiskit/qiskit/issues/12655 for current details.
+scipy==1.13.1; python_version=='3.12'
+
 # z3-solver from 4.12.3 onwards upped the minimum macOS API version for its
 # wheels to 11.7. The Azure VM images contain pre-built CPythons, of which at
 # least CPython 3.8 was compiled for an older macOS, so does not match a

crates/accelerate/Cargo.toml

@@ -20,7 +20,7 @@ num-traits = "0.2"
 num-complex.workspace = true
 num-bigint = "0.4"
 rustworkx-core = "0.14"
-faer = "0.19.0"
+faer = "0.19.1"
 itertools = "0.13.0"
 qiskit-circuit.workspace = true
 

crates/accelerate/src/lib.rs

@@ -23,12 +23,12 @@ pub mod isometry;
 pub mod nlayout;
 pub mod optimize_1q_gates;
 pub mod pauli_exp_val;
-pub mod permutation;
 pub mod results;
 pub mod sabre;
 pub mod sampled_exp_val;
 pub mod sparse_pauli_op;
 pub mod stochastic_swap;
+pub mod synthesis;
 pub mod target_transpiler;
 pub mod two_qubit_decompose;
 pub mod uc_gate;

crates/accelerate/src/synthesis/mod.rs

@@ -0,0 +1,22 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+mod permutation;
+
+use pyo3::prelude::*;
+use pyo3::wrap_pymodule;
+
+#[pymodule]
+pub fn synthesis(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pymodule!(permutation::permutation))?;
+    Ok(())
+}

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

@@ -0,0 +1,68 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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 numpy::PyArrayLike1;
+use smallvec::smallvec;
+
+use pyo3::prelude::*;
+use pyo3::wrap_pyfunction;
+
+use qiskit_circuit::circuit_data::CircuitData;
+use qiskit_circuit::operations::{Param, StandardGate};
+use qiskit_circuit::Qubit;
+
+mod utils;
+
+/// Checks whether an array of size N is a permutation of 0, 1, ..., N - 1.
+#[pyfunction]
+#[pyo3(signature = (pattern))]
+pub fn _validate_permutation(py: Python, pattern: PyArrayLike1<i64>) -> PyResult<PyObject> {
+    let view = pattern.as_array();
+    utils::validate_permutation(&view)?;
+    Ok(py.None())
+}
+
+/// Finds inverse of a permutation pattern.
+#[pyfunction]
+#[pyo3(signature = (pattern))]
+pub fn _inverse_pattern(py: Python, pattern: PyArrayLike1<i64>) -> PyResult<PyObject> {
+    let view = pattern.as_array();
+    let inverse_i64: Vec<i64> = utils::invert(&view).iter().map(|&x| x as i64).collect();
+    Ok(inverse_i64.to_object(py))
+}
+
+#[pyfunction]
+#[pyo3(signature = (pattern))]
+pub fn _synth_permutation_basic(py: Python, pattern: PyArrayLike1<i64>) -> PyResult<CircuitData> {
+    let view = pattern.as_array();
+    let num_qubits = view.len();
+    CircuitData::from_standard_gates(
+        py,
+        num_qubits as u32,
+        utils::get_ordered_swap(&view).iter().map(|(i, j)| {
+            (
+                StandardGate::SwapGate,
+                smallvec![],
+                smallvec![Qubit(*i as u32), Qubit(*j as u32)],
+            )
+        }),
+        Param::Float(0.0),
+    )
+}
+
+#[pymodule]
+pub fn permutation(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(_validate_permutation, m)?)?;
+    m.add_function(wrap_pyfunction!(_inverse_pattern, m)?)?;
+    m.add_function(wrap_pyfunction!(_synth_permutation_basic, m)?)?;
+    Ok(())
+}

crates/accelerate/src/permutation.rs → crates/accelerate/src/synthesis/permutation/utils.rs

@@ -11,12 +11,11 @@
 // that they have been altered from the originals.
 
 use ndarray::{Array1, ArrayView1};
-use numpy::PyArrayLike1;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use std::vec::Vec;
 
-fn validate_permutation(pattern: &ArrayView1<i64>) -> PyResult<()> {
+pub fn validate_permutation(pattern: &ArrayView1<i64>) -> PyResult<()> {
     let n = pattern.len();
     let mut seen: Vec<bool> = vec![false; n];
 
@@ -47,15 +46,24 @@ fn validate_permutation(pattern: &ArrayView1<i64>) -> PyResult<()> {
     Ok(())
 }
 
-fn invert(pattern: &ArrayView1<i64>) -> Array1<usize> {
+pub fn invert(pattern: &ArrayView1<i64>) -> Array1<usize> {
     let mut inverse: Array1<usize> = Array1::zeros(pattern.len());
     pattern.iter().enumerate().for_each(|(ii, &jj)| {
         inverse[jj as usize] = ii;
     });
     inverse
 }
 
-fn get_ordered_swap(pattern: &ArrayView1<i64>) -> Vec<(i64, i64)> {
+/// Sorts the input permutation by iterating through the permutation list
+/// and putting each element to its correct position via a SWAP (if it's not
+/// at the correct position already). If ``n`` is the length of the input
+/// permutation, this requires at most ``n`` SWAPs.
+///
+/// More precisely, if the input permutation is a cycle of length ``m``,
+/// then this creates a quantum circuit with ``m-1`` SWAPs (and of depth ``m-1``);
+/// if the input  permutation consists of several disjoint cycles, then each cycle
+/// is essentially treated independently.
+pub fn get_ordered_swap(pattern: &ArrayView1<i64>) -> Vec<(i64, i64)> {
     let mut permutation: Vec<usize> = pattern.iter().map(|&x| x as usize).collect();
     let mut index_map = invert(pattern);
 
@@ -76,45 +84,3 @@ fn get_ordered_swap(pattern: &ArrayView1<i64>) -> Vec<(i64, i64)> {
     swaps[..].reverse();
     swaps
 }
-
-/// Checks whether an array of size N is a permutation of 0, 1, ..., N - 1.
-#[pyfunction]
-#[pyo3(signature = (pattern))]
-fn _validate_permutation(py: Python, pattern: PyArrayLike1<i64>) -> PyResult<PyObject> {
-    let view = pattern.as_array();
-    validate_permutation(&view)?;
-    Ok(py.None())
-}
-
-/// Finds inverse of a permutation pattern.
-#[pyfunction]
-#[pyo3(signature = (pattern))]
-fn _inverse_pattern(py: Python, pattern: PyArrayLike1<i64>) -> PyResult<PyObject> {
-    let view = pattern.as_array();
-    let inverse_i64: Vec<i64> = invert(&view).iter().map(|&x| x as i64).collect();
-    Ok(inverse_i64.to_object(py))
-}
-
-/// Sorts the input permutation by iterating through the permutation list
-/// and putting each element to its correct position via a SWAP (if it's not
-/// at the correct position already). If ``n`` is the length of the input
-/// permutation, this requires at most ``n`` SWAPs.
-///
-/// More precisely, if the input permutation is a cycle of length ``m``,
-/// then this creates a quantum circuit with ``m-1`` SWAPs (and of depth ``m-1``);
-/// if the input  permutation consists of several disjoint cycles, then each cycle
-/// is essentially treated independently.
-#[pyfunction]
-#[pyo3(signature = (permutation_in))]
-fn _get_ordered_swap(py: Python, permutation_in: PyArrayLike1<i64>) -> PyResult<PyObject> {
-    let view = permutation_in.as_array();
-    Ok(get_ordered_swap(&view).to_object(py))
-}
-
-#[pymodule]
-pub fn permutation(m: &Bound<PyModule>) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(_validate_permutation, m)?)?;
-    m.add_function(wrap_pyfunction!(_inverse_pattern, m)?)?;
-    m.add_function(wrap_pyfunction!(_get_ordered_swap, m)?)?;
-    Ok(())
-}

crates/accelerate/src/target_transpiler/mod.rs

@@ -127,17 +127,9 @@ impl IntoPy<PyObject> for NormalOperation {
 
 impl ToPyObject for NormalOperation {
     fn to_object(&self, py: Python<'_>) -> PyObject {
-        operation_type_and_data_to_py(
-            py,
-            &self.operation,
-            &self.params,
-            &None,
-            &None,
-            &None,
-            &None,
-        )
-        .ok()
-        .to_object(py)
+        operation_type_and_data_to_py(py, &self.operation, &self.params, None, None, None, None)
+            .ok()
+            .to_object(py)
     }
 }