Fix segfault in EvolveResult.final_expectation_values() when no observables provided (#4065)

<!--
Thanks for helping us improve CUDA-Q!

⚠️ The pull request title should be concise and understandable for all.
⚠️ If your pull request fixes an open issue, please link to the issue.

Checklist:
- [ ] I have added tests to cover my changes.
- [ ] I have updated the documentation accordingly.
- [ ] I have read the CONTRIBUTING document.
-->

### Description
<!-- Include relevant issues here, describe what changed and why -->
EvolveResult.final_expectation_values() and EvolveResult.final_state()
crash with a segfault when the underlying std::optional fields are
nullopt. This happens when evolve() is called without observables —
expectation_values is never populated, but the accessor directly
dereferences it without checking.
The method's own docstring states "This value will be None if no
observables were specified in the call", but the actual behavior is a
segfault. Users can see this docstring in Python via:
```
>>> help(cudaq.EvolveResult.final_expectation_values)
```
**How to reproduce**:
```
import cudaq
from cudaq.operators import *
from cudaq.dynamics import *
import numpy as np

cudaq.set_target('density-matrix-cpu')

hamiltonian = 2 * np.pi * 0.1 * spin.x(0)
dimensions = {0: 2}
rho0 = cudaq.State.from_data(
    np.array([[1.0, 0.0], [0.0, 0.0]], dtype=np.complex128))

steps = np.linspace(0, 10, 11)
schedule = Schedule(steps, ["time"])

result = cudaq.evolve(hamiltonian, dimensions, schedule, rho0)
result.final_expectation_values()  # Segmentation fault
```
Fix:
Add has_value() and empty() checks in py_EvolveResult.cpp for both
final_expectation_values() and final_state(). Return py::none() when the
data is not available, consistent with the documented behavior.

Signed-off-by: huaweil <huaweil@nvidia.com>
Co-authored-by: Sachin Pisal <spisal@nvidia.com>

Author: huaweil-nv

python/runtime/common/py_EvolveResult.cpp

@@ -35,11 +35,15 @@ void bindEvolveResult(py::module &mod) {
       .def(py::init<std::vector<state>, std::vector<std::vector<double>>>())
       .def(
           "final_state",
-          [](evolve_result &self) { return self.states->back(); },
+          [](evolve_result &self) -> py::object {
+            if (!self.states.has_value() || self.states->empty())
+              return py::none();
+            return py::cast(self.states->back());
+          },
           "Stores the final state produced by a call to :func:`evolve`. "
           "Represent the state of a quantum system after time evolution under "
           "a set of operators, see the :func:`evolve` documentation for more "
-          "detail.\n")
+          "detail. Returns None if no states are available.\n")
       .def(
           "intermediate_states",
           [](evolve_result &self) { return self.states; },
@@ -50,7 +54,12 @@ void bindEvolveResult(py::module &mod) {
           ":func:`evolve`.\n")
       .def(
           "final_expectation_values",
-          [](evolve_result &self) { return self.expectation_values->back(); },
+          [](evolve_result &self) -> py::object {
+            if (!self.expectation_values.has_value() ||
+                self.expectation_values->empty())
+              return py::none();
+            return py::cast(self.expectation_values->back());
+          },
           "Stores the final expectation values, that is the results produced "
           "by "
           "calls to :func:`observe`, triggered by a call to :func:`evolve`. "

python/tests/dynamics/test_evolve_simulators.py

@@ -461,6 +461,36 @@ def test_evolve_no_intermediate_results():
     assert final_exp_decay[0][1].expectation() != final_exp[0][1].expectation()
 
 
+def test_final_expectation_values_without_observables():
+    """Test that final_expectation_values returns None instead of crashing
+    when evolve is called without observables."""
+
+    hamiltonian = 2 * np.pi * 0.1 * spin.x(0)
+    dimensions = {0: 2}
+    rho0 = cudaq.State.from_data(
+        np.array([[1.0, 0.0], [0.0, 0.0]], dtype=np.complex128))
+
+    steps = np.linspace(0, 10, 11)
+    schedule = Schedule(steps, ["time"])
+
+    # Evolve without observables
+    result = cudaq.evolve(
+        hamiltonian,
+        dimensions,
+        schedule,
+        rho0,
+        store_intermediate_results=cudaq.IntermediateResultSave.NONE)
+
+    # final_expectation_values should return None, not segfault
+    assert result.final_expectation_values() is None
+
+    # expectation_values should also be None
+    assert result.expectation_values() is None
+
+    # final_state should still work
+    assert result.final_state() is not None
+
+
 # leave for gdb debugging
 if __name__ == "__main__":
     loc = os.path.abspath(__file__)