Cleaner implementation: use parameter vector ROOT uuid as key, resolve element uuids from root uuid

ElePT · ElePT · commit 87ae03e104d8 · 2025-06-03T16:21:44.000+02:00
diff --git a/qiskit/qpy/binary_io/circuits.py b/qiskit/qpy/binary_io/circuits.py
@@ -167,7 +167,6 @@ def _loads_instruction_parameter(
     circuit,
     use_symengine,
     standalone_vars,
-    initialize_full_vec,
 ):
     if type_key == type_keys.Program.CIRCUIT:
         param = common.data_from_binary(data_bytes, read_circuit, version=version)
@@ -187,7 +186,6 @@ def _loads_instruction_parameter(
                 circuit=circuit,
                 use_symengine=use_symengine,
                 standalone_vars=standalone_vars,
-                initialize_full_vec=initialize_full_vec,
             )
         )
     elif type_key == type_keys.Value.INTEGER:
@@ -209,7 +207,6 @@ def _loads_instruction_parameter(
             cregs=registers["c"],
             use_symengine=use_symengine,
             standalone_vars=standalone_vars,
-            initialize_full_vec=initialize_full_vec,
         )
 
     return param
@@ -297,14 +294,6 @@ def _read_instruction(
     # Load Parameters
     for _param in range(instruction.num_parameters):
         type_key, data_bytes = common.read_generic_typed_data(file_obj)
-        # If the gate is in the list of exceptions (subclasses of BlueprintCircuit),
-        # and the parameter type is a parameter vector, initialize all elements of
-        # the vector. This is to avoid unnecessary UserWarnings about elements in
-        # the non-user-actionable parameter vector not being initialized.
-        initialize_full_vec = any(
-            exception in gate_name
-            for exception in ["ZZFeatureMap", "ZFeatureMap", "PauliFeatureMap"]
-        )
         param = _loads_instruction_parameter(
             type_key,
             data_bytes,
@@ -314,7 +303,6 @@ def _read_instruction(
             circuit,
             use_symengine,
             standalone_vars,
-            initialize_full_vec,
         )
         params.append(param)
 
diff --git a/qiskit/qpy/binary_io/value.py b/qiskit/qpy/binary_io/value.py
@@ -453,28 +453,28 @@ def _read_parameter(file_obj):
     return Parameter(name, uuid=param_uuid)
 
 
-def _read_parameter_vec(file_obj, vectors, initialize_full_vec):
+def _read_parameter_vec(file_obj, vectors):
     data = formats.PARAMETER_VECTOR_ELEMENT(
         *struct.unpack(
             formats.PARAMETER_VECTOR_ELEMENT_PACK,
             file_obj.read(formats.PARAMETER_VECTOR_ELEMENT_SIZE),
         ),
     )
-    # Starting in version 15, the parameter uuid is used instead of the
-    # parameter name.
-    param_uuid = uuid.UUID(bytes=data.uuid)
+    # Starting in version 15, the parameter vector root uuid
+    # is used as a key instead of the parameter name.
+    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 param_uuid not in vectors:
-        vectors[param_uuid] = (ParameterVector(name, data.vector_size), set())
-    vector = vectors[param_uuid][0]
-    if initialize_full_vec:
-        for index in range(data.vector_size):
-            vectors[param_uuid][1].add(index)
-            vector._params[index] = ParameterVectorElement(vector, index, uuid=param_uuid)
-    elif vector[data.index].uuid != param_uuid:
-        vectors[param_uuid][1].add(data.index)
-        vector._params[data.index] = ParameterVectorElement(vector, data.index, uuid=param_uuid)
+    if root_uuid not in vectors:
+        vectors[root_uuid] = (ParameterVector(name, data.vector_size), set())
+    vector = vectors[root_uuid][0]
+
+    if vector[data.index].uuid != root_uuid:
+        vectors[root_uuid][1].add(data.index)
+        vector._params[data.index] = ParameterVectorElement(
+            vector, data.index, uuid=uuid.UUID(int=root_uuid_int + data.index)
+        )
     return vector[data.index]
 
 
@@ -540,7 +540,7 @@ def _read_parameter_expression_v3(file_obj, vectors, use_symengine):
             symbol = _read_parameter(file_obj)
         elif symbol_key == type_keys.Value.PARAMETER_VECTOR:
             # If a parameter vector is used within an expression, initialize all elements.
-            symbol = _read_parameter_vec(file_obj, vectors, initialize_full_vec=True)
+            symbol = _read_parameter_vec(file_obj, vectors)
         else:
             raise exceptions.QpyError(f"Invalid parameter expression map type: {symbol_key}")
 
@@ -589,7 +589,7 @@ def _read_parameter_expression_v13(file_obj, vectors, version):
             symbol = _read_parameter(file_obj)
         elif symbol_key == type_keys.Value.PARAMETER_VECTOR:
             # If a parameter vector is used within an expression, initialize all elements.
-            symbol = _read_parameter_vec(file_obj, vectors, initialize_full_vec=True)
+            symbol = _read_parameter_vec(file_obj, vectors)
         elif symbol_key == type_keys.Value.PARAMETER_EXPRESSION:
             symbol = _read_parameter_expression_v13(file_obj, vectors, version)
 
@@ -658,7 +658,6 @@ def _read_parameter_expr_v13(buf, symbol_map, version, vectors):
                     deserializer=loads_value,
                     version=version,
                     vectors=vectors,
-                    initialize_full_vec=True,
                 )
             # Starting in version 15, the uuid is used instead of the name
             if version < 15:
@@ -1072,7 +1071,6 @@ def loads_value(
     cregs=None,
     use_symengine=False,
     standalone_vars=(),
-    initialize_full_vec=False,
 ):
     """Deserialize input binary data to value object.
 
@@ -1089,11 +1087,6 @@ def loads_value(
             before setting this option, as it will be required by qpy to deserialize the payload.
         standalone_vars (Sequence[Var]): standalone :class:`.expr.Var` nodes in the order that they
             were declared by the circuit header.
-        initialize_full_vec (bool): If True, de-serialized parameter vectors will be considered
-            fully initialized independently of whether all elements are currently used the
-            circuit or not. This flag is set to True when loading parameter expressions to avoid
-            raising unnecessary user warnings.
-
     Returns:
         any: Deserialized value object.
 
@@ -1124,7 +1117,6 @@ def loads_value(
             binary_data,
             _read_parameter_vec,
             vectors=vectors,
-            initialize_full_vec=initialize_full_vec,
         )
     if type_key == type_keys.Value.PARAMETER:
         return common.data_from_binary(binary_data, _read_parameter)
diff --git a/test/python/circuit/test_circuit_load_from_qpy.py b/test/python/circuit/test_circuit_load_from_qpy.py
@@ -53,9 +53,11 @@
     DiagonalGate,
     PauliFeatureMap,
     ZZFeatureMap,
+    RealAmplitudes,
     pauli_feature_map,
     zz_feature_map,
     qaoa_ansatz,
+    real_amplitudes,
 )
 from qiskit.circuit.annotated_operation import (
     AnnotatedOperation,
@@ -888,23 +890,45 @@ def test_op_evolution_gate_suzuki_trotter(self):
         self.assertIsInstance(new_evo, PauliEvolutionGate)
         self.assertDeprecatedBitProperties(qc, new_circ)
 
-    def test_pauli_feature_map(self):
+    def test_pauli_feature_map_new(self):
         """Regression test for
         https://github.com/Qiskit/qiskit/issues/13720."""
-        # legacy construction
-        qc = PauliFeatureMap(feature_dimension=5, reps=1)
+        # new construction
+        qc = pauli_feature_map(feature_dimension=5, reps=1)
         qpy_file = io.BytesIO()
         dump(qc, qpy_file)
         qpy_file.seek(0)
-        new_circuit = load(qpy_file)[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),
+                    )
+                )
         self.assertEqual(qc, new_circuit)
 
-        # new construction
-        qc = pauli_feature_map(feature_dimension=5, reps=1)
+    def test_pauli_feature_map_legacy(self):
+        """Regression test for
+        https://github.com/Qiskit/qiskit/issues/13720."""
+        # legacy construction
+        with self.assertWarns(DeprecationWarning):
+            qc = PauliFeatureMap(feature_dimension=5, reps=1)
         qpy_file = io.BytesIO()
         dump(qc, qpy_file)
         qpy_file.seek(0)
-        new_circuit = load(qpy_file)[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),
+                    )
+                )
         self.assertEqual(qc, new_circuit)
 
     def test_zz_feature_map_new(self):
@@ -929,7 +953,66 @@ def test_zz_feature_map_new(self):
     def test_zz_feature_map_legacy(self):
         """Regression test for
         https://github.com/Qiskit/qiskit/issues/14088."""
-        qc = ZZFeatureMap(2, reps=1)
+        with self.assertWarns(DeprecationWarning):
+            qc = ZZFeatureMap(2, reps=1)
+        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),
+                    )
+                )
+        self.assertEqual(qc, new_circuit)
+
+    def test_zz_feature_map_new(self):
+        """Regression test for
+        https://github.com/Qiskit/qiskit/issues/14088."""
+        qc = zz_feature_map(2, reps=1)
+        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),
+                    )
+                )
+        self.assertEqual(qc, new_circuit)
+
+    def test_real_amplitudes_legacy(self):
+        """Regression test for
+        https://github.com/Qiskit/qiskit/issues/14088."""
+        with self.assertWarns(DeprecationWarning):
+            qc = RealAmplitudes(2, reps=1)
+        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),
+                    )
+                )
+        self.assertEqual(qc, new_circuit)
+
+    def test_real_amplitudes_new(self):
+        """Regression test for
+        https://github.com/Qiskit/qiskit/issues/14088."""
+        qc = real_amplitudes(2, reps=1)
         qpy_file = io.BytesIO()
         dump(qc, qpy_file)
         qpy_file.seek(0)
@@ -952,7 +1035,8 @@ def test_duplicated_param_name_legacy(self):
         x = ParameterVector("γ", 1)
 
         # legacy construction
-        ansatz = QAOAAnsatz(op, reps=1)
+        with self.assertWarns(DeprecationWarning):
+            ansatz = QAOAAnsatz(op, reps=1)
         ansatz = ansatz.assign_parameters({ansatz.parameters[1]: x[0]})
         qc = QuantumCircuit(4)
         qc.append(ansatz, range(4))
