Remove QPY warning on deserialising incomplete ParameterVectors

This warning was added with QPY v3[^1] at a time when `ParameterVector`
generated all its elements with unrelated UUIDs.  Since `qiskit-terra`
v0.25, we actually _have_ had enough information to completely recreate
an entire vector from a single element[^2], and the circumstances needed
to observe the incomplete behaviour are particularly convoluted, and
unlikely in practice.

[^1]: 5c4cd2b: Fix ParameterVector handling in QPY serialization (gh-7381)
[^2]: 5ab231d: Slightly optimize ParameterVector construction (gh-10403)

Author: jakelishman

crates/qpy/src/circuit_reader.rs

@@ -1518,35 +1518,6 @@ pub(crate) fn unpack_circuit(
         let inst = unpack_instruction(instruction, &custom_instructions, &mut qpy_data)?;
         qpy_data.circuit_data.push(inst)?;
     }
-    for (vector, initialized_params) in qpy_data.vectors.values() {
-        let vector_length = vector
-            .bind(py)
-            .call_method0("__len__")?
-            .extract::<usize>()?;
-        let missing_indices: Vec<u64> = (0..vector_length as u64)
-            .filter(|x| !initialized_params.contains(&(*x as u32)))
-            .collect();
-        if initialized_params.len() != vector_length {
-            let msg = format!(
-                "The ParameterVector: '{:}' is not fully identical to its \
-                pre-serialization state. Elements {:} \
-                in the ParameterVector will be not equal to the pre-serialized ParameterVector \
-                as they weren't used in the circuit: {:}",
-                vector.getattr(py, "name")?.extract::<String>(py)?,
-                missing_indices
-                    .iter()
-                    .map(|index| index.to_string())
-                    .collect::<Vec<_>>()
-                    .join(", "),
-                packed_circuit.header.circuit_name
-            );
-            imports::WARNINGS_WARN.get_bound(py).call1((
-                msg,
-                imports::BUILTIN_USER_WARNING.get_bound(py),
-                1,
-            ))?;
-        }
-    }
     // since we don't have a rust QuantumCircuit, and the metadata and custom layouts are also in python
     // this pythonic part is unavoidable
     let unpacked_layout = unpack_layout(py, &packed_circuit.layout, &circuit_data)?;

crates/qpy/src/params.rs

@@ -543,7 +543,7 @@ pub(crate) fn unpack_parameter_vector(
 
     let vector = Python::attach(|py| -> Result<_, QpyError> {
         // we use python-space to interface with the ParameterVector data
-        let vector_data = match qpy_data.vectors.get_mut(&root_uuid) {
+        let vector = match qpy_data.vectors.get(&root_uuid) {
             Some(value) => value,
             None => Python::attach(|py| -> Result<_, QpyError> {
                 // we use python-space to create a new parameter vector
@@ -557,17 +557,13 @@ pub(crate) fn unpack_parameter_vector(
                     .get_bound(py)
                     .call1((name.clone(), parameter_vector_pack.vector_size, py_uuid))?
                     .unbind();
-                qpy_data
-                    .vectors
-                    .insert(root_uuid, (vector, Default::default()));
-                qpy_data.vectors.get_mut(&root_uuid).ok_or_else(|| {
+                qpy_data.vectors.insert(root_uuid, vector);
+                qpy_data.vectors.get(&root_uuid).ok_or_else(|| {
                     QpyError::MissingData("Parameter vector creation failed".to_string())
                 })
             })?,
         };
-        let vector = vector_data.0.bind(py);
-        vector_data.1.insert(index);
-        Ok(vector.clone().unbind())
+        Ok(vector.clone_ref(py))
     })?;
 
     Ok(Symbol {

crates/qpy/src/value.rs

@@ -15,7 +15,7 @@ use std::sync::Arc;
 
 use binrw::meta::{ReadEndian, WriteEndian};
 use binrw::{BinRead, BinWrite, Endian, binrw};
-use hashbrown::{HashMap, HashSet};
+use hashbrown::HashMap;
 use pyo3::prelude::*;
 use pyo3::types::PyAny;
 
@@ -126,7 +126,7 @@ pub struct QPYReadData<'a> {
     pub use_symengine: bool,
     pub standalone_vars: HashMap<u16, qiskit_circuit::Var>,
     pub standalone_stretches: HashMap<u16, qiskit_circuit::Stretch>,
-    pub vectors: HashMap<Uuid, (Py<PyAny>, HashSet<u32>)>, // Parameter expression vectors, which are a python-only elements for now
+    pub vectors: HashMap<Uuid, Py<PyAny>>, // Parameter expression vectors, which are a python-only elements for now
     pub annotation_handler: AnnotationHandler<'a>,
 }
 

qiskit/qpy/binary_io/circuits.py

@@ -1805,16 +1805,6 @@ def read_circuit(
     if version >= 5:
         _read_calibrations(file_obj, version, vectors, metadata_deserializer)
 
-    for vector, initialized_params in vectors.values():
-        if len(initialized_params) != len(vector):
-            warnings.warn(
-                f"The ParameterVector: '{vector.name}' is not fully identical to its "
-                "pre-serialization state. Elements "
-                f"{', '.join([str(x) for x in set(range(len(vector))) - initialized_params])} "
-                "in the ParameterVector will be not equal to the pre-serialized ParameterVector "
-                f"as they weren't used in the circuit: {circ.name}",
-                UserWarning,
-            )
     if version >= 8:
         if version >= 10:
             _read_layout_v2(file_obj, circ)

qiskit/qpy/binary_io/value.py

@@ -458,11 +458,8 @@ def _read_parameter_vec(file_obj, vectors):
     root_uuid_int = uuid.UUID(bytes=data.uuid).int - data.index
     root_uuid = uuid.UUID(int=root_uuid_int)
     name = file_obj.read(data.vector_name_size).decode(common.ENCODE)
-
-    if root_uuid not in vectors:
-        vectors[root_uuid] = (ParameterVector(name, data.vector_size, uuid=root_uuid), set())
-    vector = vectors[root_uuid][0]
-    vectors[root_uuid][1].add(data.index)
+    if (vector := vectors.get(root_uuid, None)) is None:
+        vector = vectors[root_uuid] = ParameterVector(name, data.vector_size, uuid=root_uuid)
     return vector[data.index]
 
 

releasenotes/notes/no-warn-vector-qpy-28ecc9aefafcfd8e.yaml

@@ -0,0 +1,28 @@
+---
+fixes:
+  - QPY deserialization no longer emits a warning when loading a circuit that uses some, but not all,
+    elements of a :class:`.ParameterVector`.
+
+issues:
+  - |
+    QPY files generated by ``qiskit-terra`` v0.24 and prior may define :class:`.ParameterVector`
+    instances whose elements have disconnected :attr:`.Parameter.uuid`
+    attributes, which cannot be completely round-tripped.  Prior to this version of Qiskit, QPY
+    would emit a warning if it detected an implicit :class:`.ParameterVector` that had not been
+    completely reconstructed.  QPY will no longer warn in this situtation.
+
+    In order to observe the dangerous behavior, all the following are required:
+
+    * you load two separate QPY circuit payloads (in the same file, or separate files) generated by
+      ``qiskit-terra`` v0.24 or earlier.
+    * the two circuits use :class:`.ParameterVectorElement` instances derived from the same
+      :class:`.ParameterVector`.
+    * one circuit uses a particular element from the vector, and the other does not use it.
+    * you attempt to compare the directly deserialized :class:`.ParameterVectorElement` from the
+      circuit that used it to the same element index, but retrieved through the
+      :attr:`.ParameterVectorElement.vector` backreference of a different element from the circuit
+      that does not use the compared element.
+
+    The warning has been removed because in modern Qiskit it is a false positive far more often than
+    it indicates an observed problem.  Qiskit v2.5 onwards in fact will create an implicit
+    :class:`.ParameterVector` whose elements compare equal between circuits.

test/python/circuit/test_circuit_load_from_qpy.py

@@ -19,8 +19,6 @@
 import random
 import tempfile
 import unittest
-import warnings
-import re
 
 import ddt
 import numpy as np
@@ -925,16 +923,7 @@ def test_pauli_feature_map_legacy(self):
         qpy_file = io.BytesIO()
         dump(qc, qpy_file)
         qpy_file.seek(0)
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            new_circuit = load(qpy_file)[0]
-            for warning in w:
-                self.assertFalse(
-                    re.search(
-                        r"is not fully identical to its pre-serialization state",
-                        str(warning.message),
-                    )
-                )
+        new_circuit = load(qpy_file)[0]
         self.assertEqual(qc, new_circuit)
 
     def test_pauli_feature_map_new(self):
@@ -945,16 +934,7 @@ def test_pauli_feature_map_new(self):
         qpy_file = io.BytesIO()
         dump(qc, qpy_file)
         qpy_file.seek(0)
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            new_circuit = load(qpy_file)[0]
-            for warning in w:
-                self.assertFalse(
-                    re.search(
-                        r"is not fully identical to its pre-serialization state",
-                        str(warning.message),
-                    )
-                )
+        new_circuit = load(qpy_file)[0]
         self.assertEqual(qc, new_circuit)
 
     def test_zz_feature_map_legacy(self):
@@ -966,16 +946,7 @@ def test_zz_feature_map_legacy(self):
         qpy_file = io.BytesIO()
         dump(qc, qpy_file)
         qpy_file.seek(0)
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            new_circuit = load(qpy_file)[0]
-            for warning in w:
-                self.assertFalse(
-                    re.search(
-                        r"is not fully identical to its pre-serialization state",
-                        str(warning.message),
-                    )
-                )
+        new_circuit = load(qpy_file)[0]
         self.assertEqual(qc, new_circuit)
 
     def test_zz_feature_map_new(self):
@@ -986,16 +957,7 @@ def test_zz_feature_map_new(self):
         qpy_file = io.BytesIO()
         dump(qc, qpy_file)
         qpy_file.seek(0)
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            new_circuit = load(qpy_file)[0]
-            for warning in w:
-                self.assertFalse(
-                    re.search(
-                        r"is not fully identical to its pre-serialization state",
-                        str(warning.message),
-                    )
-                )
+        new_circuit = load(qpy_file)[0]
         self.assertEqual(qc, new_circuit)
 
     def test_real_amplitudes_legacy(self):
@@ -1007,16 +969,7 @@ def test_real_amplitudes_legacy(self):
         qpy_file = io.BytesIO()
         dump(qc, qpy_file)
         qpy_file.seek(0)
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            new_circuit = load(qpy_file)[0]
-            for warning in w:
-                self.assertFalse(
-                    re.search(
-                        r"is not fully identical to its pre-serialization state",
-                        str(warning.message),
-                    )
-                )
+        new_circuit = load(qpy_file)[0]
         self.assertEqual(qc, new_circuit)
 
     def test_real_amplitudes_new(self):
@@ -1027,16 +980,7 @@ def test_real_amplitudes_new(self):
         qpy_file = io.BytesIO()
         dump(qc, qpy_file)
         qpy_file.seek(0)
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            new_circuit = load(qpy_file)[0]
-            for warning in w:
-                self.assertFalse(
-                    re.search(
-                        r"is not fully identical to its pre-serialization state",
-                        str(warning.message),
-                    )
-                )
+        new_circuit = load(qpy_file)[0]
         self.assertEqual(qc, new_circuit)
 
     def test_duplicated_param_name_legacy(self):
@@ -1053,16 +997,7 @@ def test_duplicated_param_name_legacy(self):
         qpy_file = io.BytesIO()
         dump(qc, qpy_file)
         qpy_file.seek(0)
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            new_circuit = load(qpy_file)[0]
-            for warning in w:
-                self.assertFalse(
-                    re.search(
-                        r"is not fully identical to its pre-serialization state",
-                        str(warning.message),
-                    )
-                )
+        new_circuit = load(qpy_file)[0]
         self.assertEqual(qc, new_circuit)
 
     def test_duplicated_param_name_new(self):
@@ -1078,16 +1013,7 @@ def test_duplicated_param_name_new(self):
         qpy_file = io.BytesIO()
         dump(qc, qpy_file)
         qpy_file.seek(0)
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            new_circuit = load(qpy_file)[0]
-            for warning in w:
-                self.assertFalse(
-                    re.search(
-                        r"is not fully identical to its pre-serialization state",
-                        str(warning.message),
-                    )
-                )
+        new_circuit = load(qpy_file)[0]
         self.assertEqual(qc, new_circuit)
 
     def test_parameter_expression_global_phase(self):
@@ -1165,8 +1091,7 @@ def dump_load_param_vec(qc):
             x = ParameterVector("γ", 2)
             qc = QuantumCircuit(3)
             qc.rzz(x[0], 0, 1)
-            with self.assertWarns(UserWarning):
-                params, new_params, vector, new_vector = dump_load_param_vec(qc)
+            params, new_params, vector, new_vector = dump_load_param_vec(qc)
 
             self.assertTrue(all(p == q for p, q in zip(params, new_params)))
             # vector[0] is part of the circuit
@@ -1209,19 +1134,6 @@ def test_parameter_vector_element_in_expression(self):
         self.assertEqual([x.name for x in new_circuit.parameters], expected_params)
         self.assertDeprecatedBitProperties(qc, new_circuit)
 
-    def test_parameter_vector_incomplete_warns(self):
-        """Test that qpy's deserialization warns if a ParameterVector isn't fully identical."""
-        vec = ParameterVector("test", 3)
-        qc = QuantumCircuit(1, name="fun")
-        qc.rx(vec[1], 0)
-        qpy_file = io.BytesIO()
-        dump(qc, qpy_file)
-        qpy_file.seek(0)
-        with self.assertWarnsRegex(UserWarning, r"^The ParameterVector.*Elements 0, 2.*fun$"):
-            new_circuit = load(qpy_file)[0]
-        self.assertEqual(qc, new_circuit)
-        self.assertDeprecatedBitProperties(qc, new_circuit)
-
     def test_parameter_vector_global_phase(self):
         """Test that a circuit with a standalone ParameterVectorElement phase works."""
         vec = ParameterVector("phase", 1)