Merge remote-tracking branch 'ibm/main' into oxidize-ctrl-flow

Author: jakelishman

crates/cext/src/transpiler/target.rs

@@ -24,7 +24,7 @@ use qiskit_circuit::operations::{Operation, Param, StandardGate};
 use qiskit_circuit::packed_instruction::PackedOperation;
 use qiskit_circuit::parameter::parameter_expression::ParameterExpression;
 use qiskit_circuit::parameter::symbol_expr::Symbol;
-use qiskit_transpiler::target::{InstructionProperties, Qargs, Target};
+use qiskit_transpiler::target::{InstructionProperties, Qargs, Target, TargetOperation};
 use smallvec::{SmallVec, smallvec};
 
 /// @ingroup QkTarget
@@ -943,6 +943,93 @@ pub unsafe extern "C" fn qk_target_num_instructions(target: *const Target) -> us
     target.len()
 }
 
+/// @ingroup QkTarget
+/// Checks if the provided instruction and its qargs are supported by this
+/// ``Target``.
+///
+/// @param target A pointer to the ``Target``.
+/// @param operation_name The instruction name to check for.
+/// @param qargs The pointer to the array of ``uint32_t`` values to use as
+/// qargs. Can be ``NULL`` if global.
+/// @param params A pointer to an array of pointers of ``QkParam`` objects as parameters
+/// to check. Can be ``NULL`` if no parameters are present.
+///
+/// @return Whether the instruction is supported or not.
+///
+/// # Example
+/// ```c
+///     // Create a mock target with only a global crx entry
+///     // and 3.14 as its rotation parameter.
+///     QkTarget *target = qk_target_new(5);
+///     QkTargetEntry *crx_entry = qk_target_entry_new_fixed(QkGate_CRX, (double[]){3.14});
+///     qk_target_entry_add_property(crx_entry, NULL, 0, 0.0, 0.1);
+///     qk_target_add_instruction(target, crx_entry);
+///
+///     // Check if target is compatible with a "crx" gate
+///     // at [0, 1] with 3.14 rotation.
+///     QkParam *params[1] = {qk_param_from_double(3.14)};
+///     qk_target_instruction_supported(target, "crx", (uint32_t []){0, 1}, params);
+///
+///     // Free the pointers
+///     qk_param_free(params[0]);  
+///     qk_target_free(target);  
+/// ```
+///
+/// # Safety
+///
+/// Behavior is undefined if ``target`` is not a valid, non-null pointer to a ``QkTarget``.
+///
+/// The ``qargs`` argument is expected to be a pointer to an array of ``u32int_t`` where the length
+/// matches the expectation of the gate. If the array is insufficiently long the behavior of this
+/// function is undefined as this will read outside the bounds of the array. It can be a null
+/// pointer if there are no qubits for a given gate. You can check `qk_gate_num_qubits` to
+/// determine how many qubits are required for a given gate.
+///
+/// The ``params`` argument is expected to be an array of ``QkParam`` where the length matches the
+/// expectation of the operation in question. If the array is insufficiently long, the behavior will
+/// be undefined just as mentioned above for the ``qargs`` argument. You can always check ``qk_gate_num_params``
+/// in the case of a ``QkGate``.
+#[unsafe(no_mangle)]
+#[cfg(feature = "cbinding")]
+pub unsafe extern "C" fn qk_target_instruction_supported(
+    target: *const Target,
+    operation_name: *const c_char,
+    qargs: *const u32,
+    params: *mut *mut Param,
+) -> bool {
+    // SAFETY: Per documentation, the pointer is non-null and aligned.
+    let target = unsafe { const_ptr_as_ref(target) };
+    // SAFETY: Per documentation, the pointer for operation name points to a valid null terminated string.
+    let name = unsafe { CStr::from_ptr(operation_name) }
+        .to_str()
+        .expect("Error extracting gate name from target.");
+    let Some(operation) = target.operation_from_name(name) else {
+        return false;
+    };
+    let num_params = match operation {
+        TargetOperation::Variadic(_) => 0,
+        TargetOperation::Normal(op) => op.params.as_ref().map(|p| p.len()).unwrap_or(0),
+    };
+
+    // SAFETY: Per documentation, the params argument points to an appropriately allocated
+    // array of valid pointers to `QkParam` objects.
+    let params = if params.is_null() {
+        Vec::with_capacity(0)
+    } else {
+        unsafe {
+            std::slice::from_raw_parts(params, num_params)
+                .iter()
+                .map(|param| const_ptr_as_ref(*param).clone())
+                .collect()
+        }
+    };
+
+    // SAFETY: Per the documentation the qubits pointer is an array of num_qubits elements
+    let qargs: Qargs = unsafe { parse_qargs(qargs, operation.num_qubits()) };
+
+    target.instruction_supported(name, &qargs, &params, false)
+}
+
 /// Parses qargs based on a pointer and its size.
 ///
 /// # Arguments

crates/transpiler/src/target/mod.rs

@@ -1375,12 +1375,14 @@ impl Target {
                     return false;
                 }
 
-                for (index, params) in parameters.iter().enumerate() {
-                    let obj_at_index = &obj_params[index];
-                    let matching_params = match (obj_at_index, params) {
+                for (params, orig_params) in parameters.iter().zip(obj_params) {
+                    let matching_params = match (orig_params, params) {
                         (Param::Float(obj_f), Param::Float(param_f)) => obj_f == param_f,
                         (Param::ParameterExpression(_), _) => true,
-                        _ => Python::attach(|py| python_compare(py, params, &obj_params[index]))
+                        (Param::Float(obj_f), Param::ParameterExpression(expr)) => {
+                            expr.try_to_value(true).is_ok_and(|value| value.eq(obj_f))
+                        }
+                        _ => Python::attach(|py| python_compare(py, params, orig_params))
                             .expect("Error comparing Python parameters."),
                     };
 

qiskit/user_config.py

@@ -190,11 +190,18 @@ def read_config_file(self):
                 self.settings["sabre_all_threads"] = sabre_all_threads
 
             # Parse min_qpy_version
-            min_qpy_version = self.config_parser.getint("default", "min_qpy_version", fallback=None)
+            try:
+                min_qpy_version = self.config_parser.getint(
+                    "default", "min_qpy_version", fallback=None
+                )
+            except ValueError as ve:
+                raise exceptions.QiskitUserConfigError(
+                    "min_qpy_version is not a valid QPY version."
+                ) from ve
             if min_qpy_version:
                 if min_qpy_version < 0:
                     raise exceptions.QiskitUserConfigError(
-                        f"{min_qpy_version} is not a valid QPY version."
+                        f"min_qpy_version {min_qpy_version} is not a valid QPY version."
                     )
                 self.settings["min_qpy_version"] = min_qpy_version
 

releasenotes/notes/add-instruction-supported-6323e618f04ae77e.yaml

@@ -0,0 +1,7 @@
+---
+features_c:
+  - |
+    Add function :c:func:`qk_target_instruction_supported` to check the compatibility of any gate
+    or instruction with the instance of :c:type:`QkTarget`. This check is performed based
+    on the provided instruction's name, qargs, and parameters. For more information on how it works
+    read the examples listed in the documentation for :c:func:`qk_target_instruction_supported`.

test/c/test_target.c

@@ -20,6 +20,7 @@
 #include <stdio.h>
 #include <string.h>
 
+QkTarget *create_sample_target(bool std_inst);
 /**
  * Test empty constructor for Target
  */
@@ -552,6 +553,89 @@ static int test_target_update_instruction(void) {
     return result;
 }
 
+/**
+ * Test if our target is compatible with certain instructions.
+ */
+int test_target_instruction_supported(void) {
+    QkTarget *sample_target = create_sample_target(true);
+    int result = Ok;
+
+    char *gate_names[7] = {"x", "y", "id", "rz", "sx", "reset"};
+    QkParam *rz_params[1] = {
+        qk_param_from_double(3.14),
+    };
+    for (uint32_t qubit = 0; qubit < 5; qubit++) {
+        uint32_t qargs[1] = {qubit};
+        bool should_be_true = qubit < 4;
+
+        for (int gate = 0; gate < 6; gate++) {
+            // If i == 4 condition should be false unless we try with the y gate
+            // since y is added as a global gate.
+            if (qk_target_instruction_supported(sample_target, gate_names[gate], qargs,
+                                                gate != 3 ? NULL : rz_params) !=
+                (should_be_true || gate == 1)) {
+                printf("This target did not correctly demonstrate compatibility with %s and qargs "
+                       "[%d]",
+                       gate_names[gate], qubit);
+                result = EqualityError;
+                goto cleanup;
+            }
+        }
+
+        // Try checking with the wrong fixed parameter for RZ
+        QkParam *param = qk_param_from_double(1.57);
+        if (qk_target_instruction_supported(sample_target, "rz", qargs,
+                                            (QkParam *[]){
+                                                param,
+                                            })) {
+            printf("This target did not correctly demonstrate compatibility with 'rz' and qargs "
+                   "[%d]",
+                   qubit);
+            result = EqualityError;
+            qk_param_free(param);
+            goto cleanup;
+        }
+
+        // Test standard instructions reset and measure
+        if (!(qk_target_instruction_supported(sample_target, "measure", qargs, NULL) ==
+              (qubit < 2))) {
+            printf(
+                "This target did not correctly demonstrate compatibility with 'measure' and qargs "
+                "[%d]",
+                qubit);
+            result = EqualityError;
+            goto cleanup;
+        }
+    }
+
+    // Qarg samples for CX
+    uint32_t qarg_samples[8][2] = {
+        {3, 4}, {4, 3}, {3, 1}, {1, 3}, {1, 2}, {2, 1}, {0, 1}, {1, 0},
+    };
+    for (int i = 0; i < 8; i++) {
+        if (!qk_target_instruction_supported(sample_target, "cx", qarg_samples[i], NULL)) {
+            printf("This target did incorrectly demonstrate compatibility with 'cx' and qargs [%d, "
+                   "%d]",
+                   qarg_samples[i][0], qarg_samples[i][1]);
+            result = EqualityError;
+            goto cleanup;
+        }
+    }
+
+    uint32_t cx_qargs[2] = {3, 2};
+    // Instruction should not show compatibility with (3, 2)
+    if (qk_target_instruction_supported(sample_target, "cx", cx_qargs, NULL)) {
+        printf("This target did incorrectly demonstrate compatibility with 'cx' and qargs [3, 2]");
+        result = EqualityError;
+        goto cleanup;
+    }
+
+cleanup:
+    qk_param_free(rz_params[0]);
+    qk_target_free(sample_target);
+    return result;
+}
+
 int test_target(void) {
     int num_failed = 0;
     num_failed += RUN_TEST(test_empty_target);
@@ -560,9 +644,77 @@ int test_target(void) {
     num_failed += RUN_TEST(test_target_add_instruction);
     num_failed += RUN_TEST(test_target_update_instruction);
     num_failed += RUN_TEST(test_target_construction_ibm_like_target);
+    num_failed += RUN_TEST(test_target_instruction_supported);
 
     fflush(stderr);
     fprintf(stderr, "=== Number of failed subtests: %i\n", num_failed);
 
     return num_failed;
 }
+
+QkTarget *create_sample_target(bool std_inst) {
+    // Build sample target
+    QkTarget *target = qk_target_new(0);
+    QkTargetEntry *i_entry = qk_target_entry_new(QkGate_I);
+    for (int i = 0; i < 4; i++) {
+        uint32_t qargs[1] = {i};
+        qk_target_entry_add_property(i_entry, qargs, 1, 35.5e-9, 0.);
+    }
+    qk_target_add_instruction(target, i_entry);
+
+    double rz_params[1] = {3.14};
+    QkTargetEntry *rz_entry = qk_target_entry_new_fixed(QkGate_RZ, rz_params, NULL);
+    for (int i = 0; i < 4; i++) {
+        uint32_t qargs[1] = {i};
+        qk_target_entry_add_property(rz_entry, qargs, 1, 0., 0.);
+    }
+    qk_target_add_instruction(target, rz_entry);
+
+    QkTargetEntry *sx_entry = qk_target_entry_new(QkGate_SX);
+    for (int i = 0; i < 4; i++) {
+        uint32_t qargs[1] = {i};
+        qk_target_entry_add_property(sx_entry, qargs, 1, 35.5e-9, 0.);
+    }
+    qk_target_add_instruction(target, sx_entry);
+
+    QkTargetEntry *x_entry = qk_target_entry_new(QkGate_X);
+    for (int i = 0; i < 4; i++) {
+        uint32_t qargs[1] = {i};
+        qk_target_entry_add_property(x_entry, qargs, 1, 35.5e-9, 0.0005);
+    }
+    qk_target_add_instruction(target, x_entry);
+
+    QkTargetEntry *cx_entry = qk_target_entry_new(QkGate_CX);
+    uint32_t qarg_samples[8][2] = {
+        {3, 4}, {4, 3}, {3, 1}, {1, 3}, {1, 2}, {2, 1}, {0, 1}, {1, 0},
+    };
+    double props[8][2] = {
+        {2.7022e-11, 0.00713}, {3.0577e-11, 0.00713}, {4.6222e-11, 0.00929}, {4.9777e-11, 0.00929},
+        {2.2755e-11, 0.00659}, {2.6311e-11, 0.00659}, {5.1911e-11, 0.01201}, {5.1911e-11, 0.01201},
+    };
+    for (int i = 0; i < 8; i++) {
+        qk_target_entry_add_property(cx_entry, qarg_samples[i], 2, props[i][0], props[i][1]);
+    }
+    qk_target_add_instruction(target, cx_entry);
+
+    // Add global Y Gate
+    qk_target_add_instruction(target, qk_target_entry_new(QkGate_Y));
+
+    if (std_inst) {
+        QkTargetEntry *meas = qk_target_entry_new_measure();
+        for (uint32_t i = 0; i < 2; i++) {
+            uint32_t q[1] = {i};
+            qk_target_entry_add_property(meas, q, 1, 1e-6, 1e-4);
+        }
+        qk_target_add_instruction(target, meas);
+
+        QkTargetEntry *reset = qk_target_entry_new_reset();
+        for (uint32_t i = 0; i < 4; i++) {
+            uint32_t q[1] = {i};
+            qk_target_entry_add_property(reset, q, 1, 1e-6, 1e-4);
+        }
+        qk_target_add_instruction(target, reset);
+    }
+
+    return target;
+}

test/python/qpy/test_min_qpy_version.py

@@ -0,0 +1,60 @@
+"""Tests for min_qpy_version option"""
+
+# 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.
+
+import struct
+from unittest import mock
+import unittest
+from uuid import uuid4
+import io
+
+from qiskit.qpy import load, formats, QpyError
+
+
+class TestMinQpyVersion(unittest.TestCase):
+    """Tests for min_qpy_version validation."""
+
+    def setUp(self):
+        super().setUp()
+        self.file_path = f"test_{uuid4()}.conf"
+
+    @mock.patch("qiskit.user_config.get_config")
+    def test_enforce_min_qpy_version(self, mock_get_config):
+        """Test that QPY file below min_qpy_version raises QiskitError."""
+        mock_get_config.return_value = {"min_qpy_version": 12}
+        with io.BytesIO() as buf:
+            buf.write(struct.pack(formats.FILE_HEADER_PACK, b"QISKIT", 9, 1, 0, 0, 0))
+            buf.seek(0)
+            with self.assertRaises(QpyError) as cm:
+                load(buf)
+        self.assertIn("is lower than the configured minimum version", str(cm.exception))
+
+    @mock.patch("qiskit.user_config.get_config")
+    def test_matches_min_qpy_version(self, mock_get_config):
+        """Test that QPY file matches min_qpy_version."""
+        mock_get_config.return_value = {"min_qpy_version": 4}
+        with io.BytesIO() as buf:
+            buf.write(struct.pack(formats.FILE_HEADER_PACK, b"QISKIT", 4, 1, 0, 0, 0))
+            buf.seek(0)
+            no_circs = load(buf)
+        self.assertEqual(no_circs, [])
+
+    @mock.patch("qiskit.user_config.get_config")
+    def test_skip_enforcement_if_unset(self, mock_get_config):
+        """Test that load proceeds if min_qpy_version is unset."""
+        mock_get_config.return_value = {"min_qpy_version": None}
+        with io.BytesIO() as buf:
+            buf.write(struct.pack(formats.FILE_HEADER_PACK, b"QISKIT", 4, 1, 0, 0, 0))
+            buf.seek(0)
+            no_circs = load(buf)
+        self.assertEqual(no_circs, [])