Fix qpy.dump()'s use_symengine when passed a truthy object (#11730)

This commit fixes an issue in the qpy dump() function's use_symengine
kwarg. When a user provided a truthy value that wasn't the literal
`Truth` boolean object the generated qpy payload would be corrupted.
That's because the check that assigns the encoding key in the file
header was unecessarily checking for the literal ``True`` object instead
of a object that evaluated to true. This was causing the header to say
it was using a sympy encoding, but then all the checks that were
encoding the data were evaluating true and setting symengine data. This
would cause a failure on reading the qpy payload when the parameter
expressions were parsed as it would try to load the binary symengine
encoding with the sympy parser.

qiskit/qpy/type_keys.py

@@ -541,7 +541,7 @@ class SymExprEncoding(TypeKeyBase):
 
     @classmethod
     def assign(cls, obj):
-        if obj is True:
+        if obj:
             return cls.SYMENGINE
         else:
             return cls.SYMPY

releasenotes/notes/fix-qpy-use-symengine-bool-like-d17550057a58abf2.yaml

@@ -0,0 +1,9 @@
+---
+fixes:
+  - |
+    Fixed an issue with the :func:`.qpy.dump` function, when the
+    ``use_symengine`` flag was set to a truthy object that evaluated to
+    ``True`` but was not actually the boolean ``True`` the generated QPY
+    payload would be corrupt. For example, if you set ``use_symengine`` to
+    :obj:`.HAS_SYMENGINE` which evaluates to ``True`` when cast as a bool,
+    but isn't actually ``True``.

test/python/qpy/test_circuit_load_from_qpy.py

@@ -25,16 +25,21 @@
 from qiskit.transpiler import PassManager, TranspileLayout
 from qiskit.transpiler import passes
 from qiskit.compiler import transpile
+from qiskit.utils import optionals
+from qiskit.qpy.formats import FILE_HEADER_V10_PACK, FILE_HEADER_V10, FILE_HEADER_V10_SIZE
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
 
 
 class QpyCircuitTestCase(QiskitTestCase):
     """QPY schedule testing platform."""
 
-    def assert_roundtrip_equal(self, circuit, version=None):
+    def assert_roundtrip_equal(self, circuit, version=None, use_symengine=None):
         """QPY roundtrip equal test."""
         qpy_file = io.BytesIO()
-        dump(circuit, qpy_file, version=version)
+        if use_symengine is None:
+            dump(circuit, qpy_file, version=version)
+        else:
+            dump(circuit, qpy_file, version=version, use_symengine=use_symengine)
         qpy_file.seek(0)
         new_circuit = load(qpy_file)[0]
 
@@ -296,3 +301,29 @@ def test_compatibility_version_roundtrip(self):
         qc.cx(0, 1)
         qc.measure_all()
         self.assert_roundtrip_equal(qc, version=QPY_COMPATIBILITY_VERSION)
+
+
+class TestUseSymengineFlag(QpyCircuitTestCase):
+    """Test that the symengine flag works correctly."""
+
+    def test_use_symengine_with_bool_like(self):
+        """Test that the use_symengine flag is set correctly with a bool-like input."""
+        theta = Parameter("theta")
+        two_theta = 2 * theta
+        qc = QuantumCircuit(1)
+        qc.rx(two_theta, 0)
+        qc.measure_all()
+        # Assert Roundtrip works
+        self.assert_roundtrip_equal(qc, use_symengine=optionals.HAS_SYMENGINE, version=10)
+        # Also check the qpy symbolic expression encoding is correct in the
+        # payload
+        with io.BytesIO() as file_obj:
+            dump(qc, file_obj, use_symengine=optionals.HAS_SYMENGINE)
+            file_obj.seek(0)
+            header_data = FILE_HEADER_V10._make(
+                struct.unpack(
+                    FILE_HEADER_V10_PACK,
+                    file_obj.read(FILE_HEADER_V10_SIZE),
+                )
+            )
+            self.assertEqual(header_data.symbolic_encoding, b"e")