From 5dae720175e96b2b7b33f3a9d2c9177713f096e0 Mon Sep 17 00:00:00 2001
From: Matthieu Darcy <68646255+MatthieuDarcy@users.noreply.github.com>
Date: Wed, 19 Aug 2026 15:38:49 -0400
Subject: [PATCH 1/8] added the option to use "previous_transition" in
 dsx.simulate

Add observation_control_alignment for discrete-time Simulator (#312)

Add an explicit observation_control_alignment: Literal["same_time",
"previous_transition"] field to DynamicalModel, defaulting to "same_time"
(today's behavior, unchanged). "previous_transition" pairs y_{k+1} with u_k
(the control that produced x_{k+1}) instead of pairing y_k with u_k, matching
DiscreteControlLoopSimulator's existing closed-loop convention and avoiding
the acausal y_0-depends-on-u_0 coupling.

For "previous_transition", DiscreteTimeSimulator/dsx.simulate never samples
y_0 and excludes x_0/t_0 from the returned SimulatedResult -- states,
observations, times, and the caller's ctrl_values all end up the same length,
with no padding or off-by-one bookkeeping required.

Scope: the plain Simulator/DiscreteTimeSimulator/dsx.simulate generation path
only. mppi.py and discrete_controller_simulators.py are unchanged, deferred
to a follow-up.
---
 dynestyx/api.py                   |  12 +-
 dynestyx/handlers.py              |   8 +-
 dynestyx/models/checkers.py       |  26 +++++
 dynestyx/models/core.py           |  22 +++-
 dynestyx/simulation/discrete.py   | 187 +++++++++++++++++++++++++-----
 dynestyx/types.py                 |  10 ++
 dynestyx/utils.py                 |  19 ++-
 tests/test_models_core.py         |  57 +++++++++
 tests/test_simulate_standalone.py | 149 ++++++++++++++++++++++++
 9 files changed, 457 insertions(+), 33 deletions(-)

diff --git a/dynestyx/api.py b/dynestyx/api.py
index 67d2b6c6..7b9b4574 100644
--- a/dynestyx/api.py
+++ b/dynestyx/api.py
@@ -55,7 +55,9 @@ def simulate(
         dynamics: Dynamical model to simulate.
         rng_key: JAX pseudorandom number generator key.
         ctrl_times: Times associated with `ctrl_values`. If controls are
-            provided, these times must match `predict_times`.
+            provided, these times must match `predict_times` for models with
+            `dynamics.observation_control_alignment="same_time"` (default), or
+            `predict_times[:-1]` for `"previous_transition"`.
         ctrl_values: Control values, or `None` for an uncontrolled model.
         predict_times: Times at which to simulate states and observations.
         n_simulations: Number of independent trajectories to simulate.
@@ -97,7 +99,13 @@ def simulate(
 
     _validate_site_sorting(ctrl_times, name="ctrl_times")
     _validate_site_sorting(predict_times, name="predict_times")
-    _validate_controls(None, predict_times, ctrl_times, ctrl_values)
+    _validate_controls(
+        None,
+        predict_times,
+        ctrl_times,
+        ctrl_values,
+        observation_control_alignment=dynamics.observation_control_alignment,
+    )
     _validate_control_dim(dynamics, ctrl_values)
 
     dynamics_with_t0 = _get_dynamics_with_t0(dynamics, None, predict_times)
diff --git a/dynestyx/handlers.py b/dynestyx/handlers.py
index 5b8bfe29..e4a9fb06 100644
--- a/dynestyx/handlers.py
+++ b/dynestyx/handlers.py
@@ -100,7 +100,13 @@ def _validate_and_prepare(
     _validate_site_sorting(ctrl_times, name="ctrl_times")
     _validate_site_sorting(predict_times, name="predict_times")
 
-    _validate_controls(obs_times, predict_times, ctrl_times, ctrl_values)
+    _validate_controls(
+        obs_times,
+        predict_times,
+        ctrl_times,
+        ctrl_values,
+        observation_control_alignment=dynamics.observation_control_alignment,
+    )
     _validate_control_dim(dynamics, ctrl_values)
 
     # Initial dynamics may not have t0, which is then inferred from obs_times
diff --git a/dynestyx/models/checkers.py b/dynestyx/models/checkers.py
index c778700f..a2ac7765 100644
--- a/dynestyx/models/checkers.py
+++ b/dynestyx/models/checkers.py
@@ -235,6 +235,32 @@ def _validate_categorical_state(
         )
 
 
+_VALID_OBSERVATION_CONTROL_ALIGNMENTS = ("same_time", "previous_transition")
+
+
+def _validate_observation_control_alignment(
+    observation_control_alignment: str, continuous_time: bool
+) -> None:
+    """Validate the observation/control alignment convention.
+
+    Unlike continuous_time/categorical_state, this field has no inferred
+    counterpart -- it is purely user-supplied with a default, so this only
+    checks (1) the value is one of the two supported literals and (2)
+    'previous_transition' is only used with discrete-time state evolution.
+    """
+    if observation_control_alignment not in _VALID_OBSERVATION_CONTROL_ALIGNMENTS:
+        raise ValueError(
+            "observation_control_alignment must be one of "
+            f"{_VALID_OBSERVATION_CONTROL_ALIGNMENTS}, got "
+            f"{observation_control_alignment!r}."
+        )
+    if observation_control_alignment == "previous_transition" and continuous_time:
+        raise ValueError(
+            "observation_control_alignment='previous_transition' is only "
+            "supported for discrete-time models (continuous_time=False)."
+        )
+
+
 def _inside_numpyro_plate_context() -> bool:
     """Return True when currently executing inside any active numpyro.plate frame."""
     return any(
diff --git a/dynestyx/models/core.py b/dynestyx/models/core.py
index f2550301..b5e79333 100644
--- a/dynestyx/models/core.py
+++ b/dynestyx/models/core.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Protocol, cast, runtime_checkable
+from typing import Any, Literal, Protocol, cast, runtime_checkable
 
 import equinox as eqx
 import jax
@@ -22,6 +22,7 @@
     _validate_continuous_time_flag,
     _validate_discrete_state_evolution_output_shape,
     _validate_imex_potential_conflict,
+    _validate_observation_control_alignment,
     _validate_observation_dim,
     _validate_state_dim,
 )
@@ -103,7 +104,16 @@ class DynamicalModel(eqx.Module):
             exactly; a mismatch raises a ``ValueError`` at simulation time.
         continuous_time (bool): Whether the model uses continuous-time state evolution (SDE) or discrete-time.
             Gets set automatically from the concrete type of `state_evolution`.
-    
+        observation_control_alignment ("same_time" | "previous_transition"): Convention for how
+            observations pair with controls in discrete time. `"same_time"` (default) pairs
+            $y_k$ with $u_k$, matching today's `dsx.simulate` behavior. `"previous_transition"`
+            pairs $y_{k+1}$ with $u_k$ (the control that produced $x_{k+1}$), matching
+            `DiscreteControlLoopSimulator`'s closed-loop convention; under this convention
+            $y_0$ is never sampled. Only `"same_time"` is honored outside the plain
+            `Simulator`/`DiscreteTimeSimulator`/`dsx.simulate` generation path (not yet by
+            Filter/Smoother/`LatentPathBuilder` posterior rollout, `DiscreteControlLoopSimulator`,
+            or `mppi.py` -- see [issue #312](https://github.com/BasisResearch/dynestyx/issues/312)).
+
     Note:
         - `continuous_time`, `state_dim`, `observation_dim`, and `categorical_state` are inferred automatically; do not pass them to the constructor.
         - Logic for control_model is not implemented yet.
@@ -127,6 +137,7 @@ class DynamicalModel(eqx.Module):
     observation_dim: int
     categorical_state: bool
     continuous_time: bool
+    observation_control_alignment: Literal["same_time", "previous_transition"]
 
     def __init__(
         self,
@@ -141,12 +152,19 @@ def __init__(
         observation_dim: int | None = None,
         categorical_state: bool | None = None,
         continuous_time: bool | None = None,
+        observation_control_alignment: Literal[
+            "same_time", "previous_transition"
+        ] = "same_time",
     ):
         inferred_continuous_time = isinstance(
             state_evolution, ContinuousTimeStateEvolution
         )
         _validate_continuous_time_flag(continuous_time, inferred_continuous_time)
         self.continuous_time = inferred_continuous_time
+        _validate_observation_control_alignment(
+            observation_control_alignment, self.continuous_time
+        )
+        self.observation_control_alignment = observation_control_alignment
         self.initial_condition = initial_condition
         self.state_evolution = state_evolution
         self.observation_model = observation_model
diff --git a/dynestyx/simulation/discrete.py b/dynestyx/simulation/discrete.py
index 45a60135..8b3da0af 100644
--- a/dynestyx/simulation/discrete.py
+++ b/dynestyx/simulation/discrete.py
@@ -13,6 +13,7 @@
 from dynestyx.simulation.utils import (
     _ensure_trailing_dim,
     _sample_initial_states,
+    _sample_observation_path,
     _tile_times,
 )
 from dynestyx.types import SimulatedResult
@@ -49,10 +50,25 @@ def _sample_discrete_state_path_from_initial_state(
     initial_state: Real[Array, " state_dim"] | Real[Array, ""],
     rng_key: PRNGKeyArray,
     times: Real[Array, " time"],
-    ctrl_values: Real[Array, "time control_dim"] | Real[Array, " time"] | None,
-) -> Real[Array, "time state_dim"] | Real[Array, " time"]:
-    """Sample one canonical discrete state path from a fixed initial state."""
-    if len(times) == 1:
+    ctrl_values: Real[Array, "ctrl_time control_dim"]
+    | Real[Array, " ctrl_time"]
+    | None,
+    include_initial_condition: bool = True,
+) -> Real[Array, "state_path_time state_dim"] | Real[Array, " state_path_time"]:
+    """Sample one canonical discrete state path from a fixed initial state.
+
+    ctrl_values has its own length ("ctrl_time"), decoupled from `times`: it
+    is len(times) for same_time (one entry per transition plus one unused by
+    any transition, reserved for the final same_time observation) or
+    len(times) - 1 for previous_transition (exactly one entry per
+    transition). The returned path's length also depends on
+    include_initial_condition, hence the separate "state_path_time" name.
+
+    Returns x_0..x_{T-1} when include_initial_condition is True (same_time
+    convention, default). Returns x_1..x_{T-1} only when False
+    (previous_transition convention) -- x_0 is the given seed, not re-emitted.
+    """
+    if len(times) == 1 and include_initial_condition:
         return jnp.expand_dims(initial_state, axis=0)
 
     state_transition = cast(DiscreteStateTransition, dynamics.state_evolution)
@@ -74,7 +90,77 @@ def _step(carry, t_idx):
         (initial_state, rng_key),
         jnp.arange(len(times) - 1),
     )
-    return jnp.concatenate([jnp.expand_dims(initial_state, 0), scan_states], axis=0)
+    if include_initial_condition:
+        return jnp.concatenate([jnp.expand_dims(initial_state, 0), scan_states], axis=0)
+    return scan_states
+
+
+def _sample_discrete_observation_path(
+    dynamics: DynamicalModel,
+    *,
+    states: Real[Array, "obs_path_time state_dim"] | Real[Array, " obs_path_time"],
+    times: Real[Array, " time"],
+    ctrl_values: Real[Array, "obs_path_time control_dim"]
+    | Real[Array, " obs_path_time"]
+    | None,
+    rng_key: PRNGKeyArray,
+    include_initial_condition: bool = True,
+) -> Real[Array, "obs_path_time observation_dim"] | Real[Array, " obs_path_time"]:
+    """Sample observations for a discrete state path.
+
+    states/ctrl_values/the return value all share one length ("obs_path_time"),
+    decoupled from `times` (always the full predict_times grid, length T):
+    that shared length is T for same_time or T-1 for previous_transition.
+
+    include_initial_condition=True (same_time, default): states/times are the
+    FULL path (length T, x_0/t_0 included); delegates to the shared
+    _sample_observation_path so same_time logic has one source of truth,
+    unchanged from today.
+
+    include_initial_condition=False (previous_transition): states is
+    x_1..x_{T-1} (length T-1, the output of the state function above with
+    include_initial_condition=False); times is still the FULL predict_times
+    (length T) so times[k+1] is available. y_{k+1} ~ p(x_{k+1}, ctrl_values[k],
+    t_{k+1}), k=0..T-2. y_0 is never sampled -- no wasted draw.
+    """
+    if include_initial_condition:
+        ctrl_eval = (
+            (lambda t: ctrl_values[jnp.searchsorted(times, t, side="left")])
+            if ctrl_values is not None
+            else None
+        )
+        return _sample_observation_path(
+            dynamics,
+            states=states,
+            times=times,
+            rng_key=rng_key,
+            control_path_eval=ctrl_eval,
+        )
+
+    n = states.shape[0]
+    obs_keys = jr.split(rng_key, n)
+    future_times = times[1:]
+
+    # Map directly over the pre-sliced arrays (states/ctrl_values/future_times/
+    # obs_keys) rather than indexing by a scanned integer inside the mapped
+    # body. jax.vmap traces its body once regardless of batch size, so
+    # indexing into a genuinely zero-length array (the n=0 edge case, e.g.
+    # predict_times of length 1) raises immediately; mapping over already-
+    # sliced arrays instead lets vmap's native zero-size handling take over,
+    # with no indexing operation in the body at all.
+    if ctrl_values is None:
+
+        def _sample_one(x_next, t_next, key):
+            obs_dist = dynamics.observation_model(x=x_next, u=None, t=t_next)
+            return obs_dist.sample(key)
+
+        return jax.vmap(_sample_one)(states, future_times, obs_keys)
+
+    def _sample_one(x_next, u, t_next, key):
+        obs_dist = dynamics.observation_model(x=x_next, u=u, t=t_next)
+        return obs_dist.sample(key)
+
+    return jax.vmap(_sample_one)(states, ctrl_values, future_times, obs_keys)
 
 
 def _sample_discrete_state_path(
@@ -108,7 +194,10 @@ class DiscreteTimeSimulator(BaseSimulator):
     r"""Generate trajectories from a discrete-time dynamical model.
 
     For prediction times \(t_0,\ldots,t_{T-1}\), this simulator draws
-    `n_simulations` independent paths according to
+    `n_simulations` independent paths. The observation/control pairing
+    depends on `dynamics.observation_control_alignment`:
+
+    For `"same_time"` (default):
 
     \[
     x_0^{(m)} \sim p_0(x_0), \qquad
@@ -121,7 +210,30 @@ class DiscreteTimeSimulator(BaseSimulator):
     The first state in the returned path is the initial-condition draw at
     `predict_times[0]`; the simulator then makes one transition draw for each
     adjacent pair of prediction times and samples one observation conditional
-    on every realized state. See
+    on every realized state, including \(y_0\) (paired with \(u_0\)).
+
+    For `"previous_transition"`:
+
+    \[
+    x_0^{(m)} \sim p_0(x_0), \qquad
+    x_{k+1}^{(m)} \sim p\!\left(x_{k+1}\mid x_k^{(m)},u_k,t_k,t_{k+1}\right),
+    \qquad
+    y_{k+1}^{(m)} \sim p(y_{k+1}\mid x_{k+1}^{(m)},u_k,t_{k+1}).
+    \]
+
+    Here \(x_0\) is only the seed for the rollout: \(y_0\) is never sampled,
+    and neither \(x_0\) nor \(t_0\) appears in the returned result --
+    `SimulatedResult.x_0` is `None` and `.times`/`.states`/`.observations` all
+    have length \(T-1\), matching the \(T-1\) controls \(u_0,\ldots,u_{T-2}\)
+    the caller supplies via `ctrl_values` (aligned to `predict_times[:-1]`,
+    not the full `predict_times`). This matches
+    [DiscreteControlLoopSimulator][dynestyx.control.discrete_controller_simulators.DiscreteControlLoopSimulator]'s
+    closed-loop convention. Only discrete-time models generated through the
+    plain `Simulator`/`DiscreteTimeSimulator`/`dsx.simulate` path honor this
+    convention today -- see
+    [issue #312](https://github.com/BasisResearch/dynestyx/issues/312).
+
+    See
     [DiscreteTimeStateEvolution][dynestyx.models.core.DiscreteTimeStateEvolution]
     for how a discrete transition model is represented in a `DynamicalModel`.
 
@@ -165,10 +277,14 @@ class DiscreteTimeSimulator(BaseSimulator):
     not be uniformly spaced, provided the model's transition accepts those
     intervals.
 
-    If controls are supplied, `ctrl_times` must contain every prediction time
-    exactly. `ctrl_values[k]` is used for the transition beginning at \(t_k\)
-    and for the observation at \(t_k\). The paired control arrays are validated
-    before simulation.
+    If controls are supplied, `ctrl_times` must exactly match the grid
+    required by `dynamics.observation_control_alignment`: the full
+    `predict_times` for `"same_time"` (default) -- `ctrl_values[k]` is used
+    for the transition beginning at \(t_k\) and for the observation at
+    \(t_k\) -- or `predict_times[:-1]` for `"previous_transition"` --
+    `ctrl_values[k]` drives the transition into \(x_{k+1}\) and the
+    observation \(y_{k+1}\). The paired control arrays are validated before
+    simulation.
 
     This handler is generation-only and does not condition on `obs_times` or
     `obs_values`. Use
@@ -250,15 +366,20 @@ def _simulate_forward_from_initial_state(
         | Real[Array, " n_simulations"],
         rng_key: PRNGKeyArray,
         times: Real[Array, " time"],
-        ctrl_values: Real[Array, "time control_dim"] | Real[Array, " time"] | None,
+        ctrl_values: Real[Array, "ctrl_time control_dim"]
+        | Real[Array, " ctrl_time"]
+        | None,
     ) -> SimulatedResult:
-        """Run pure forward simulation for a discrete-time model."""
+        """Run pure forward simulation for a discrete-time model.
+
+        ctrl_values has its own length ("ctrl_time"), decoupled from `times`
+        (always the full predict_times grid): len(times) for same_time or
+        len(times) - 1 for previous_transition.
+        """
         n_sim = initial_state.shape[0]
         sim_keys = jr.split(rng_key, n_sim)
-        ctrl_eval = (
-            (lambda t: ctrl_values[jnp.searchsorted(times, t, side="left")])
-            if ctrl_values is not None
-            else None
+        include_initial_condition = (
+            dynamics.observation_control_alignment != "previous_transition"
         )
 
         def _sim_one_trajectory(
@@ -272,22 +393,29 @@ def _sim_one_trajectory(
                 rng_key=key_states,
                 times=times,
                 ctrl_values=ctrl_values,
+                include_initial_condition=include_initial_condition,
             )
-            observations = self._emit_observations(
-                "",
+            observations = _sample_discrete_observation_path(
                 dynamics,
-                states,
-                times,
-                None,
-                ctrl_eval,
-                key=key_obs,
+                states=states,
+                times=times,
+                ctrl_values=ctrl_values,
+                rng_key=key_obs,
+                include_initial_condition=include_initial_condition,
             )
             return states, observations
 
         states, observations = jax.vmap(_sim_one_trajectory)(sim_keys, initial_state)
+        if include_initial_condition:
+            return SimulatedResult(
+                times=_tile_times(times, n_sim),
+                x_0=initial_state,
+                states=_ensure_trailing_dim(states),
+                observations=_ensure_trailing_dim(observations),
+            )
         return SimulatedResult(
-            times=_tile_times(times, n_sim),
-            x_0=initial_state,
+            times=_tile_times(times[1:], n_sim),
+            x_0=None,
             states=_ensure_trailing_dim(states),
             observations=_ensure_trailing_dim(observations),
         )
@@ -315,8 +443,13 @@ def simulate(
         if predict_times is None:
             raise ValueError("predict_times must be provided")
 
+        align_times = (
+            predict_times[:-1]
+            if dynamics.observation_control_alignment == "previous_transition"
+            else predict_times
+        )
         aligned_ctrl_values = _align_ctrl_values_to_times(
-            times=predict_times,
+            times=align_times,
             ctrl_times=ctrl_times,
             ctrl_values=ctrl_values,
         )
diff --git a/dynestyx/types.py b/dynestyx/types.py
index 5cb9e16b..38ac3469 100644
--- a/dynestyx/types.py
+++ b/dynestyx/types.py
@@ -143,6 +143,16 @@ class SimulatedResult:
     posterior rollout, the same result object instead carries
     ``predicted_times``, ``predicted_states``, and
     ``predicted_observations``.
+
+    For a discrete-time model with
+    ``dynamics.observation_control_alignment="previous_transition"``, ``x_0``
+    is ``None`` -- the seed state is not part of the rollout output -- and
+    ``times``, ``states``, and ``observations`` are all exactly the length of
+    the ``ctrl_values`` the caller supplied (one shorter than
+    ``predict_times``, since :math:`y_0` is never sampled under this
+    convention). ``x``, ``y``, ``u``, and ``t`` are therefore all the same
+    shape, with no :math:`t_0`/:math:`x_0` remnant anywhere in the result. See
+    [DiscreteTimeSimulator][dynestyx.simulation.discrete.DiscreteTimeSimulator].
     """
 
     times: Real[Array, "*plate n_simulations time"] | None = None
diff --git a/dynestyx/utils.py b/dynestyx/utils.py
index ff122ded..4311e21a 100644
--- a/dynestyx/utils.py
+++ b/dynestyx/utils.py
@@ -334,6 +334,8 @@ def _validate_controls(
     ctrl_values: Real[Array, "*ctrl_value_plate ctrl_time control_dim"]
     | Real[Array, "*ctrl_value_plate ctrl_time"]
     | None,
+    *,
+    observation_control_alignment: str = "same_time",
 ) -> None:
     """
     Validate control inputs against model time grids.
@@ -344,11 +346,22 @@ def _validate_controls(
     - If both obs_times and predict_times are present, ctrl_times must match their union.
     - Otherwise ctrl_times must match whichever single grid is provided.
     - Matching is set-like (order-insensitive) and length-preserving.
+    - When observation_control_alignment is "previous_transition", ctrl_times must
+      instead match predict_times[:-1] (one control per transition); obs_times-based
+      conditioning is not supported yet under this convention (see issue #312).
 
     Raises:
         ValueError: If controls are partially provided or no time grid is provided.
     """
 
+    if observation_control_alignment == "previous_transition" and obs_times is not None:
+        raise ValueError(
+            "observation_control_alignment='previous_transition' does not "
+            "support obs_times-based conditioning yet (Filter/Smoother/"
+            "LatentPathBuilder posterior rollout); only predict_times-only "
+            "generation is supported. See issue #312."
+        )
+
     if ctrl_times is None:
         if ctrl_values is not None:
             raise ValueError(
@@ -365,7 +378,11 @@ def _validate_controls(
     if obs_times is None and predict_times is None:
         raise ValueError("At least one of obs_times or predict_times must be provided")
 
-    if obs_times is None:
+    if observation_control_alignment == "previous_transition":
+        # obs_times is None here -- already rejected above otherwise.
+        assert predict_times is not None
+        total_obs_pred_times = predict_times[:-1]
+    elif obs_times is None:
         total_obs_pred_times = predict_times
     elif predict_times is None:
         total_obs_pred_times = obs_times
diff --git a/tests/test_models_core.py b/tests/test_models_core.py
index a877e82e..a602e3f3 100644
--- a/tests/test_models_core.py
+++ b/tests/test_models_core.py
@@ -803,3 +803,60 @@ def bad_cov_fn(t_now, t_next):
             ),
             observation_model=dsx.LinearGaussianObservation(H=jnp.eye(2), R=jnp.eye(2)),
         )
+
+
+# ---------------------------------------------------------------------------
+# observation_control_alignment field (#312)
+# ---------------------------------------------------------------------------
+
+
+def test_observation_control_alignment_defaults_to_same_time() -> None:
+    model = _simple_discrete_model()
+    assert model.observation_control_alignment == "same_time"
+
+
+def test_observation_control_alignment_previous_transition_stored() -> None:
+    model = DynamicalModel(
+        initial_condition=dist.Normal(0.0, 1.0),
+        state_evolution=lambda x, u, t_now, t_next: dist.Normal(x, 0.1),
+        observation_model=lambda x, u, t: dist.Normal(x, 0.1),
+        control_dim=0,
+        observation_control_alignment="previous_transition",
+    )
+    assert model.observation_control_alignment == "previous_transition"
+
+
+def test_observation_control_alignment_rejects_invalid_literal() -> None:
+    # Under the pytest jaxtyping import hook (see pyproject.toml addopts),
+    # jaxtyping's own Literal[...] enforcement rejects an invalid value before
+    # DynamicalModel.__init__'s body -- and _validate_observation_control_alignment
+    # within it -- ever runs, raising jaxtyping.TypeCheckError (a TypeError
+    # subclass) rather than the ValueError _validate_observation_control_alignment
+    # raises outside that instrumented context. Accept either so this test is
+    # correct with or without the import hook active.
+    with pytest.raises((ValueError, TypeError)):
+        DynamicalModel(
+            initial_condition=dist.Normal(0.0, 1.0),
+            state_evolution=lambda x, u, t_now, t_next: dist.Normal(x, 0.1),
+            observation_model=lambda x, u, t: dist.Normal(x, 0.1),
+            control_dim=0,
+            observation_control_alignment="bogus",  # ty: ignore[invalid-argument-type]
+        )
+
+
+def test_observation_control_alignment_previous_transition_rejects_continuous_time() -> (
+    None
+):
+    with pytest.raises(
+        ValueError,
+        match="observation_control_alignment='previous_transition' is only supported "
+        "for discrete-time models",
+    ):
+        DynamicalModel(
+            initial_condition=_initial_condition_2d(),
+            state_evolution=ContinuousTimeStateEvolution(
+                drift=lambda x, u, t: -0.3 * x
+            ),
+            observation_model=_observation_model_2d,
+            observation_control_alignment="previous_transition",
+        )
diff --git a/tests/test_simulate_standalone.py b/tests/test_simulate_standalone.py
index 90b02407..00ca5713 100644
--- a/tests/test_simulate_standalone.py
+++ b/tests/test_simulate_standalone.py
@@ -370,3 +370,152 @@ def model():
         "Simulator + Predictive, dsx.simulate, and pre-split Simulator.simulate "
         f"produced different values for {mismatched_fields}"
     )
+
+
+# ---------------------------------------------------------------------------
+# observation_control_alignment="previous_transition" (#312)
+# ---------------------------------------------------------------------------
+
+
+def _make_previous_transition_dynamics() -> dsx.DynamicalModel:
+    """Deterministic 1-D discrete model whose observation reveals both the
+    state and (scaled) control it was conditioned on, so tests can check
+    exactly which control an observation used."""
+
+    def _state_evolution(x, u, t_now, t_next):
+        del t_now, t_next
+        u = jnp.zeros_like(x) if u is None else u
+        return dist.Delta(x + u).to_event(1)
+
+    def _observation_model(x, u, t):
+        del t
+        u = jnp.zeros_like(x) if u is None else u
+        return dist.Delta(x + 100.0 * u).to_event(1)
+
+    return dsx.DynamicalModel(
+        control_dim=1,
+        initial_condition=dist.Delta(jnp.array([0.0])).to_event(1),
+        state_evolution=_state_evolution,
+        observation_model=_observation_model,
+        observation_control_alignment="previous_transition",
+    )
+
+
+def test_discrete_simulator_previous_transition_aligns_ctrl_values_shorter_by_one():
+    predict_times = jnp.array([0.0, 1.0, 2.0, 3.0])
+    ctrl_times = predict_times[:-1]
+    ctrl_values = jnp.array([[1.0], [2.0], [3.0]])
+
+    result = dsx.DiscreteTimeSimulator().simulate(
+        _make_previous_transition_dynamics(),
+        rng_key=jr.PRNGKey(0),
+        predict_times=predict_times,
+        ctrl_times=ctrl_times,
+        ctrl_values=ctrl_values,
+    )
+
+    states = jnp.asarray(result.states)
+    observations = jnp.asarray(result.observations)
+    times = jnp.asarray(result.times)
+
+    assert result.x_0 is None
+    assert times.shape == (1, 3)
+    assert jnp.allclose(times[0], predict_times[1:])
+    assert states.shape == (1, 3, 1)
+    assert observations.shape == (1, 3, 1)
+    # x_1=1, x_2=3, x_3=6 (cumulative sum of controls, x_0=0)
+    expected_states = jnp.array([[[1.0], [3.0], [6.0]]])
+    assert jnp.array_equal(states, expected_states)
+    # y_{k+1} = x_{k+1} + 100 * u_k
+    expected_observations = expected_states + 100.0 * jnp.array([[[1.0], [2.0], [3.0]]])
+    assert jnp.array_equal(observations, expected_observations)
+
+
+def test_discrete_simulator_previous_transition_rejects_ctrl_times_matching_full_predict_times():
+    """dsx.simulate's _validate_controls gate requires an exact-length match
+    against predict_times[:-1] for previous_transition; DiscreteTimeSimulator's
+    own _align_ctrl_values_to_times permits a superset ctrl_times, so this must
+    go through the public dsx.simulate entry point to observe the rejection."""
+    predict_times = jnp.array([0.0, 1.0, 2.0, 3.0])
+    ctrl_values = jnp.array([[1.0], [2.0], [3.0], [4.0]])
+
+    with pytest.raises(Exception):
+        dsx.simulate(
+            _make_previous_transition_dynamics(),
+            rng_key=jr.PRNGKey(0),
+            predict_times=predict_times,
+            ctrl_times=predict_times,
+            ctrl_values=ctrl_values,
+        )
+
+
+def test_dsx_simulate_previous_transition_end_to_end():
+    """Exercises dsx.simulate -> api.py -> utils.py::_validate_controls threading."""
+    predict_times = jnp.array([0.0, 1.0, 2.0, 3.0])
+    ctrl_times = predict_times[:-1]
+    ctrl_values = jnp.array([[1.0], [2.0], [3.0]])
+
+    result = dsx.simulate(
+        _make_previous_transition_dynamics(),
+        rng_key=jr.PRNGKey(0),
+        predict_times=predict_times,
+        ctrl_times=ctrl_times,
+        ctrl_values=ctrl_values,
+    )
+
+    assert result.x_0 is None
+    assert jnp.asarray(result.times).shape == (1, 3)
+    assert jnp.asarray(result.states).shape == (1, 3, 1)
+    assert jnp.asarray(result.observations).shape == (1, 3, 1)
+
+
+def test_discrete_simulator_previous_transition_zero_length_predict_times_edge_case():
+    result = dsx.simulate(
+        _make_previous_transition_dynamics(),
+        rng_key=jr.PRNGKey(0),
+        predict_times=jnp.arange(1.0),
+    )
+
+    assert result.x_0 is None
+    assert jnp.asarray(result.times).shape == (1, 0)
+    assert jnp.asarray(result.states).shape == (1, 0, 1)
+    assert jnp.asarray(result.observations).shape == (1, 0, 1)
+
+
+def test_discrete_simulator_previous_transition_rejects_obs_times():
+    predict_times = jnp.array([0.0, 1.0, 2.0])
+
+    with pytest.raises(
+        ValueError,
+        match="observation_control_alignment='previous_transition' does not support "
+        "obs_times",
+    ):
+        dsx.condition(
+            "f",
+            _make_previous_transition_dynamics(),
+            obs_times=predict_times,
+            obs_values=jnp.zeros((3, 1)),
+            predict_times=predict_times,
+        )
+
+
+def test_previous_transition_observation_uses_previous_step_control_not_same_index():
+    """y_{k+1} must use u_k (the control that produced x_{k+1}), not u_{k+1}."""
+    predict_times = jnp.array([0.0, 1.0, 2.0, 3.0])
+    ctrl_times = predict_times[:-1]
+    ctrl_values = jnp.array([[1.0], [2.0], [3.0]])
+
+    result = dsx.DiscreteTimeSimulator().simulate(
+        _make_previous_transition_dynamics(),
+        rng_key=jr.PRNGKey(0),
+        predict_times=predict_times,
+        ctrl_times=ctrl_times,
+        ctrl_values=ctrl_values,
+    )
+
+    states = jnp.asarray(result.states)
+    observations = jnp.asarray(result.observations)
+    # observation_model reveals x + 100*u, so subtracting the realized state
+    # recovers exactly which (scaled) control each observation used.
+    revealed_control = (observations - states) / 100.0
+    assert jnp.array_equal(revealed_control[0], ctrl_values)

From 14e3f4436b4210fed95416d1e946e14dfd1edfef Mon Sep 17 00:00:00 2001
From: Matthieu Darcy <68646255+MatthieuDarcy@users.noreply.github.com>
Date: Mon, 31 Aug 2026 13:34:47 -0400
Subject: [PATCH 2/8] Updated results, cleaned up some functions

Include x_0 in all results; add controls to SimulatedResult

For observation_control_alignment="previous_transition", the result now keeps
x_0 and the full times/states path (length T), matching "same_time". Only
observations stay one shorter (y_1..y_{T-1}, length T-1) since y_0 is never
sampled -- so states[k+1] pairs with observations[k].

Add a controls field to SimulatedResult carrying the aligned ctrl_values used
(length T for same_time, T-1 for previous_transition; None when uncontrolled).

Also drop the bespoke _sample_discrete_observation_path in favor of calling
_emit_observations directly with sliced states/times, and fix
_sample_observation_path to vmap over arrays rather than indexing by a scanned
integer, which crashed on zero-length observation paths.
---
 dynestyx/simulation/discrete.py   | 158 ++++++++++--------------------
 dynestyx/simulation/utils.py      |  16 +--
 dynestyx/types.py                 |  33 +++++--
 tests/test_discrete_control.py    |   8 +-
 tests/test_simulate_standalone.py | 111 ++++++++++++++++++---
 5 files changed, 189 insertions(+), 137 deletions(-)

diff --git a/dynestyx/simulation/discrete.py b/dynestyx/simulation/discrete.py
index 8b3da0af..21456dc9 100644
--- a/dynestyx/simulation/discrete.py
+++ b/dynestyx/simulation/discrete.py
@@ -13,7 +13,6 @@
 from dynestyx.simulation.utils import (
     _ensure_trailing_dim,
     _sample_initial_states,
-    _sample_observation_path,
     _tile_times,
 )
 from dynestyx.types import SimulatedResult
@@ -53,22 +52,21 @@ def _sample_discrete_state_path_from_initial_state(
     ctrl_values: Real[Array, "ctrl_time control_dim"]
     | Real[Array, " ctrl_time"]
     | None,
-    include_initial_condition: bool = True,
-) -> Real[Array, "state_path_time state_dim"] | Real[Array, " state_path_time"]:
+) -> Real[Array, "time state_dim"] | Real[Array, " time"]:
     """Sample one canonical discrete state path from a fixed initial state.
 
+    Always returns x_0..x_{T-1} (length T, matching `times`) -- x_0 is
+    included regardless of `dynamics.observation_control_alignment`; only
+    observation sampling (see `_simulate_forward_from_initial_state`) differs
+    by convention.
+
     ctrl_values has its own length ("ctrl_time"), decoupled from `times`: it
     is len(times) for same_time (one entry per transition plus one unused by
     any transition, reserved for the final same_time observation) or
     len(times) - 1 for previous_transition (exactly one entry per
-    transition). The returned path's length also depends on
-    include_initial_condition, hence the separate "state_path_time" name.
-
-    Returns x_0..x_{T-1} when include_initial_condition is True (same_time
-    convention, default). Returns x_1..x_{T-1} only when False
-    (previous_transition convention) -- x_0 is the given seed, not re-emitted.
+    transition).
     """
-    if len(times) == 1 and include_initial_condition:
+    if len(times) == 1:
         return jnp.expand_dims(initial_state, axis=0)
 
     state_transition = cast(DiscreteStateTransition, dynamics.state_evolution)
@@ -90,77 +88,7 @@ def _step(carry, t_idx):
         (initial_state, rng_key),
         jnp.arange(len(times) - 1),
     )
-    if include_initial_condition:
-        return jnp.concatenate([jnp.expand_dims(initial_state, 0), scan_states], axis=0)
-    return scan_states
-
-
-def _sample_discrete_observation_path(
-    dynamics: DynamicalModel,
-    *,
-    states: Real[Array, "obs_path_time state_dim"] | Real[Array, " obs_path_time"],
-    times: Real[Array, " time"],
-    ctrl_values: Real[Array, "obs_path_time control_dim"]
-    | Real[Array, " obs_path_time"]
-    | None,
-    rng_key: PRNGKeyArray,
-    include_initial_condition: bool = True,
-) -> Real[Array, "obs_path_time observation_dim"] | Real[Array, " obs_path_time"]:
-    """Sample observations for a discrete state path.
-
-    states/ctrl_values/the return value all share one length ("obs_path_time"),
-    decoupled from `times` (always the full predict_times grid, length T):
-    that shared length is T for same_time or T-1 for previous_transition.
-
-    include_initial_condition=True (same_time, default): states/times are the
-    FULL path (length T, x_0/t_0 included); delegates to the shared
-    _sample_observation_path so same_time logic has one source of truth,
-    unchanged from today.
-
-    include_initial_condition=False (previous_transition): states is
-    x_1..x_{T-1} (length T-1, the output of the state function above with
-    include_initial_condition=False); times is still the FULL predict_times
-    (length T) so times[k+1] is available. y_{k+1} ~ p(x_{k+1}, ctrl_values[k],
-    t_{k+1}), k=0..T-2. y_0 is never sampled -- no wasted draw.
-    """
-    if include_initial_condition:
-        ctrl_eval = (
-            (lambda t: ctrl_values[jnp.searchsorted(times, t, side="left")])
-            if ctrl_values is not None
-            else None
-        )
-        return _sample_observation_path(
-            dynamics,
-            states=states,
-            times=times,
-            rng_key=rng_key,
-            control_path_eval=ctrl_eval,
-        )
-
-    n = states.shape[0]
-    obs_keys = jr.split(rng_key, n)
-    future_times = times[1:]
-
-    # Map directly over the pre-sliced arrays (states/ctrl_values/future_times/
-    # obs_keys) rather than indexing by a scanned integer inside the mapped
-    # body. jax.vmap traces its body once regardless of batch size, so
-    # indexing into a genuinely zero-length array (the n=0 edge case, e.g.
-    # predict_times of length 1) raises immediately; mapping over already-
-    # sliced arrays instead lets vmap's native zero-size handling take over,
-    # with no indexing operation in the body at all.
-    if ctrl_values is None:
-
-        def _sample_one(x_next, t_next, key):
-            obs_dist = dynamics.observation_model(x=x_next, u=None, t=t_next)
-            return obs_dist.sample(key)
-
-        return jax.vmap(_sample_one)(states, future_times, obs_keys)
-
-    def _sample_one(x_next, u, t_next, key):
-        obs_dist = dynamics.observation_model(x=x_next, u=u, t=t_next)
-        return obs_dist.sample(key)
-
-    return jax.vmap(_sample_one)(states, ctrl_values, future_times, obs_keys)
+    return jnp.concatenate([jnp.expand_dims(initial_state, 0), scan_states], axis=0)
 
 
 def _sample_discrete_state_path(
@@ -221,12 +149,16 @@ class DiscreteTimeSimulator(BaseSimulator):
     y_{k+1}^{(m)} \sim p(y_{k+1}\mid x_{k+1}^{(m)},u_k,t_{k+1}).
     \]
 
-    Here \(x_0\) is only the seed for the rollout: \(y_0\) is never sampled,
-    and neither \(x_0\) nor \(t_0\) appears in the returned result --
-    `SimulatedResult.x_0` is `None` and `.times`/`.states`/`.observations` all
-    have length \(T-1\), matching the \(T-1\) controls \(u_0,\ldots,u_{T-2}\)
-    the caller supplies via `ctrl_values` (aligned to `predict_times[:-1]`,
-    not the full `predict_times`). This matches
+    Here \(y_0\) is never sampled -- there's no control that produced it --
+    but \(x_0\) is still part of the returned result, exactly like
+    `"same_time"`: `SimulatedResult.x_0` is populated and `.states` has length
+    \(T\) (matching `.times`/`predict_times`, \(x_0,\ldots,x_{T-1}\)).
+    `.observations` and `.controls`, however, are one shorter -- length
+    \(T-1\): \(y_1,\ldots,y_{T-1}\) and \(u_0,\ldots,u_{T-2}\) (aligned to
+    `predict_times[:-1]`, not the full `predict_times`). So `.states` is
+    intentionally one longer than `.observations`/`.controls`:
+    `states[k+1]` pairs with `observations[k]`/`controls[k]`, not
+    `states[k]`. This matches
     [DiscreteControlLoopSimulator][dynestyx.control.discrete_controller_simulators.DiscreteControlLoopSimulator]'s
     closed-loop convention. Only discrete-time models generated through the
     plain `Simulator`/`DiscreteTimeSimulator`/`dsx.simulate` path honor this
@@ -314,7 +246,13 @@ class DiscreteTimeSimulator(BaseSimulator):
     - `"f_states"`: latent states, shape
       `(*plate_shape, n_simulations, T, state_dim)`;
     - `"f_observations"`: sampled observations, shape
-      `(*plate_shape, n_simulations, T, observation_dim)`.
+      `(*plate_shape, n_simulations, T, observation_dim)` for `"same_time"`,
+      or `(*plate_shape, n_simulations, T-1, observation_dim)` for
+      `"previous_transition"`;
+    - `"f_controls"`: the (aligned) controls used, when the model is
+      controlled, shape `(*plate_shape, n_simulations, T, control_dim)` for
+      `"same_time"` or `(*plate_shape, n_simulations, T-1, control_dim)` for
+      `"previous_transition"`; absent when the model is uncontrolled.
 
     Here `"f"` is replaced by the `name` passed to `dsx.sample`. Under
     `Predictive(..., num_samples=N)`, NumPyro prepends an `N` axis to each
@@ -374,7 +312,9 @@ def _simulate_forward_from_initial_state(
 
         ctrl_values has its own length ("ctrl_time"), decoupled from `times`
         (always the full predict_times grid): len(times) for same_time or
-        len(times) - 1 for previous_transition.
+        len(times) - 1 for previous_transition. States always include x_0
+        (length matches `times`) for both conventions; only observations (and
+        the returned controls) are one shorter for previous_transition.
         """
         n_sim = initial_state.shape[0]
         sim_keys = jr.split(rng_key, n_sim)
@@ -393,31 +333,39 @@ def _sim_one_trajectory(
                 rng_key=key_states,
                 times=times,
                 ctrl_values=ctrl_values,
-                include_initial_condition=include_initial_condition,
             )
-            observations = _sample_discrete_observation_path(
-                dynamics,
-                states=states,
-                times=times,
-                ctrl_values=ctrl_values,
-                rng_key=key_obs,
-                include_initial_condition=include_initial_condition,
+            # For previous_transition, drop x_0/t_0 before sampling
+            # observations -- y_0 is never sampled under that convention.
+            # Otherwise (same_time) this is a no-op.
+            obs_states, obs_times = (
+                (states, times)
+                if include_initial_condition
+                else (states[1:], times[1:])
+            )
+            ctrl_eval = (
+                (lambda t: ctrl_values[jnp.searchsorted(obs_times, t, side="left")])
+                if ctrl_values is not None
+                else None
+            )
+            observations = self._emit_observations(
+                "", dynamics, obs_states, obs_times, None, ctrl_eval, key=key_obs
             )
             return states, observations
 
         states, observations = jax.vmap(_sim_one_trajectory)(sim_keys, initial_state)
-        if include_initial_condition:
-            return SimulatedResult(
-                times=_tile_times(times, n_sim),
-                x_0=initial_state,
-                states=_ensure_trailing_dim(states),
-                observations=_ensure_trailing_dim(observations),
+
+        controls = None
+        if ctrl_values is not None:
+            controls = _ensure_trailing_dim(
+                jnp.broadcast_to(ctrl_values[None], (n_sim, *ctrl_values.shape))
             )
+
         return SimulatedResult(
-            times=_tile_times(times[1:], n_sim),
-            x_0=None,
+            times=_tile_times(times, n_sim),
+            x_0=initial_state,
             states=_ensure_trailing_dim(states),
             observations=_ensure_trailing_dim(observations),
+            controls=controls,
         )
 
     def simulate(
diff --git a/dynestyx/simulation/utils.py b/dynestyx/simulation/utils.py
index 44bbb7f7..68eab8a4 100644
--- a/dynestyx/simulation/utils.py
+++ b/dynestyx/simulation/utils.py
@@ -9,7 +9,7 @@
 import jax.numpy as jnp
 import jax.random as jr
 import numpyro
-from jaxtyping import Array, Bool, Int, PRNGKeyArray, Real
+from jaxtyping import Array, Bool, PRNGKeyArray, Real
 
 from dynestyx.models import DynamicalModel
 from dynestyx.types import SimulatedResult, chain_numpyro_site_registrations
@@ -115,10 +115,14 @@ def _sample_observation_path(
     ctrl = control_path_eval if control_path_eval is not None else (lambda t: None)
     obs_keys = jr.split(rng_key, len(times))
 
-    def _sample_at_time(t_idx: Int[Array, ""]):
-        x_t = states[t_idx]
-        t = times[t_idx]
+    # Map directly over states/times/obs_keys rather than indexing by a
+    # scanned integer inside the mapped body: jax.vmap traces its body once
+    # regardless of batch size, so indexing into a genuinely zero-length
+    # array (e.g. a previous_transition observation path sliced down from a
+    # single-timepoint prediction grid) would raise immediately. Mapping over
+    # the arrays directly lets vmap's own batching handle the zero-size case.
+    def _sample_at(x_t, t, key):
         obs_dist = dynamics.observation_model(x=x_t, u=ctrl(t), t=t)
-        return obs_dist.sample(obs_keys[t_idx])
+        return obs_dist.sample(key)
 
-    return jax.vmap(_sample_at_time)(jnp.arange(len(times)))
+    return jax.vmap(_sample_at)(states, times, obs_keys)
diff --git a/dynestyx/types.py b/dynestyx/types.py
index 38ac3469..efc29dc0 100644
--- a/dynestyx/types.py
+++ b/dynestyx/types.py
@@ -144,17 +144,29 @@ class SimulatedResult:
     ``predicted_times``, ``predicted_states``, and
     ``predicted_observations``.
 
+    ``controls`` carries the (aligned) control values used to produce this
+    result, when the model was controlled -- ``None`` otherwise. It is
+    populated by ``DiscreteTimeSimulator`` for both
+    ``observation_control_alignment`` conventions; ODE/SDE simulators leave it
+    ``None`` for now.
+
     For a discrete-time model with
     ``dynamics.observation_control_alignment="previous_transition"``, ``x_0``
-    is ``None`` -- the seed state is not part of the rollout output -- and
-    ``times``, ``states``, and ``observations`` are all exactly the length of
-    the ``ctrl_values`` the caller supplied (one shorter than
-    ``predict_times``, since :math:`y_0` is never sampled under this
-    convention). ``x``, ``y``, ``u``, and ``t`` are therefore all the same
-    shape, with no :math:`t_0`/:math:`x_0` remnant anywhere in the result. See
+    is populated and ``states`` includes it (length :math:`T`, matching
+    ``times``), exactly like ``"same_time"``. ``observations`` and
+    ``controls``, however, are one shorter (length :math:`T-1`:
+    :math:`y_1,\\dots,y_{T-1}` and :math:`u_0,\\dots,u_{T-2}`), since
+    :math:`y_0` is never sampled under this convention -- there is no control
+    that produced it. So ``states`` is intentionally one longer than
+    ``observations``/``controls``: ``states[k+1]`` pairs with
+    ``observations[k]``/``controls[k]``, not ``states[k]``. See
     [DiscreteTimeSimulator][dynestyx.simulation.discrete.DiscreteTimeSimulator].
     """
 
+    # observations/controls use their own axis names ("obs_time"/"ctrl_time")
+    # rather than sharing "time" with times/states: under
+    # observation_control_alignment="previous_transition" they are one
+    # shorter than times/states, so jaxtyping must not enforce equal length.
     times: Real[Array, "*plate n_simulations time"] | None = None
     x_0: (
         Real[Array, "*plate n_simulations state_dim"]
@@ -167,8 +179,13 @@ class SimulatedResult:
         | None
     ) = None
     observations: (
-        Real[Array, "*plate n_simulations time observation_dim"]
-        | Real[Array, "*plate n_simulations time"]
+        Real[Array, "*plate n_simulations obs_time observation_dim"]
+        | Real[Array, "*plate n_simulations obs_time"]
+        | None
+    ) = None
+    controls: (
+        Real[Array, "*plate n_simulations ctrl_time control_dim"]
+        | Real[Array, "*plate n_simulations ctrl_time"]
         | None
     ) = None
     predicted_times: Real[Array, "*plate n_simulations predict_time"] | None = None
diff --git a/tests/test_discrete_control.py b/tests/test_discrete_control.py
index 97ba1229..bbc473ff 100644
--- a/tests/test_discrete_control.py
+++ b/tests/test_discrete_control.py
@@ -943,13 +943,15 @@ def test_dsx_simulate_with_control_policy_rejects_simulator_config():
 
 def test_dsx_simulate_without_control_policy_unchanged():
     """No control_policy given -> falls back to today's type-based routing,
-    returning a plain SimulatedResult (no controls field at all), not a
-    ControlledSimulatedResult."""
+    returning a plain SimulatedResult, not a ControlledSimulatedResult. (The
+    plain SimulatedResult does carry its own `controls` field now (#312
+    follow-up), but it's None here since no ctrl_values were supplied.)"""
     dynamics = _lti_1d()
     predict_times = jnp.arange(0.0, 5.0)
 
     result = dsx.simulate(dynamics, rng_key=jr.PRNGKey(0), predict_times=predict_times)
-    assert not hasattr(result, "controls")
+    assert not isinstance(result, ControlledSimulatedResult)
+    assert result.controls is None
 
 
 def test_initial_policy_state_threads_through_dsx_simulate():
diff --git a/tests/test_simulate_standalone.py b/tests/test_simulate_standalone.py
index 00ca5713..ac5aa4ac 100644
--- a/tests/test_simulate_standalone.py
+++ b/tests/test_simulate_standalone.py
@@ -416,18 +416,26 @@ def test_discrete_simulator_previous_transition_aligns_ctrl_values_shorter_by_on
 
     states = jnp.asarray(result.states)
     observations = jnp.asarray(result.observations)
+    controls = jnp.asarray(result.controls)
     times = jnp.asarray(result.times)
 
-    assert result.x_0 is None
-    assert times.shape == (1, 3)
-    assert jnp.allclose(times[0], predict_times[1:])
-    assert states.shape == (1, 3, 1)
-    assert observations.shape == (1, 3, 1)
-    # x_1=1, x_2=3, x_3=6 (cumulative sum of controls, x_0=0)
-    expected_states = jnp.array([[[1.0], [3.0], [6.0]]])
+    # x_0 is populated and states/times include it (length 4), like same_time.
+    assert result.x_0 is not None
+    assert jnp.array_equal(jnp.asarray(result.x_0), jnp.array([[0.0]]))
+    assert times.shape == (1, 4)
+    assert jnp.allclose(times[0], predict_times)
+    assert states.shape == (1, 4, 1)
+    # x_0=0, x_1=1, x_2=3, x_3=6 (cumulative sum of controls)
+    expected_states = jnp.array([[[0.0], [1.0], [3.0], [6.0]]])
     assert jnp.array_equal(states, expected_states)
+    # observations/controls are one shorter -- y_0 is never sampled.
+    assert observations.shape == (1, 3, 1)
+    assert controls.shape == (1, 3, 1)
+    assert jnp.array_equal(controls[0], ctrl_values)
     # y_{k+1} = x_{k+1} + 100 * u_k
-    expected_observations = expected_states + 100.0 * jnp.array([[[1.0], [2.0], [3.0]]])
+    expected_observations = expected_states[:, 1:, :] + 100.0 * jnp.array(
+        [[[1.0], [2.0], [3.0]]]
+    )
     assert jnp.array_equal(observations, expected_observations)
 
 
@@ -463,23 +471,28 @@ def test_dsx_simulate_previous_transition_end_to_end():
         ctrl_values=ctrl_values,
     )
 
-    assert result.x_0 is None
-    assert jnp.asarray(result.times).shape == (1, 3)
-    assert jnp.asarray(result.states).shape == (1, 3, 1)
+    assert result.x_0 is not None
+    assert jnp.asarray(result.times).shape == (1, 4)
+    assert jnp.asarray(result.states).shape == (1, 4, 1)
     assert jnp.asarray(result.observations).shape == (1, 3, 1)
+    assert jnp.asarray(result.controls).shape == (1, 3, 1)
 
 
 def test_discrete_simulator_previous_transition_zero_length_predict_times_edge_case():
+    """With a single prediction time, there are zero transitions/controls, so
+    observations/controls are empty -- but x_0/states/times are still the
+    (length-1) seed, same as same_time."""
     result = dsx.simulate(
         _make_previous_transition_dynamics(),
         rng_key=jr.PRNGKey(0),
         predict_times=jnp.arange(1.0),
     )
 
-    assert result.x_0 is None
-    assert jnp.asarray(result.times).shape == (1, 0)
-    assert jnp.asarray(result.states).shape == (1, 0, 1)
+    assert result.x_0 is not None
+    assert jnp.asarray(result.times).shape == (1, 1)
+    assert jnp.asarray(result.states).shape == (1, 1, 1)
     assert jnp.asarray(result.observations).shape == (1, 0, 1)
+    assert result.controls is None  # no ctrl_values supplied
 
 
 def test_discrete_simulator_previous_transition_rejects_obs_times():
@@ -517,5 +530,73 @@ def test_previous_transition_observation_uses_previous_step_control_not_same_ind
     observations = jnp.asarray(result.observations)
     # observation_model reveals x + 100*u, so subtracting the realized state
     # recovers exactly which (scaled) control each observation used.
-    revealed_control = (observations - states) / 100.0
+    # states includes x_0 (one longer than observations), so observations[k]
+    # pairs with states[k+1], not states[k].
+    revealed_control = (observations - states[:, 1:, :]) / 100.0
     assert jnp.array_equal(revealed_control[0], ctrl_values)
+
+
+def test_discrete_simulator_previous_transition_states_include_x0():
+    predict_times = jnp.array([0.0, 1.0, 2.0, 3.0])
+    ctrl_times = predict_times[:-1]
+    ctrl_values = jnp.array([[1.0], [2.0], [3.0]])
+
+    result = dsx.DiscreteTimeSimulator().simulate(
+        _make_previous_transition_dynamics(),
+        rng_key=jr.PRNGKey(0),
+        predict_times=predict_times,
+        ctrl_times=ctrl_times,
+        ctrl_values=ctrl_values,
+    )
+
+    states = jnp.asarray(result.states)
+    observations = jnp.asarray(result.observations)
+    assert jnp.array_equal(states[:, 0, :], jnp.asarray(result.x_0))
+    assert states.shape[1] == observations.shape[1] + 1
+
+
+def test_discrete_simulator_returns_controls_same_time():
+    predict_times = jnp.array([0.0, 1.0, 2.0, 3.0])
+    ctrl_values = jnp.array([[1.0], [2.0], [3.0], [4.0]])
+
+    result = dsx.DiscreteTimeSimulator().simulate(
+        _make_controlled_deterministic_discrete_dynamics(),
+        rng_key=jr.PRNGKey(0),
+        predict_times=predict_times,
+        ctrl_times=predict_times,
+        ctrl_values=ctrl_values,
+    )
+
+    assert result.controls is not None
+    assert jnp.asarray(result.controls).shape == (1, 4, 1)
+    assert jnp.array_equal(jnp.asarray(result.controls)[0], ctrl_values)
+
+
+def test_discrete_simulator_returns_controls_previous_transition():
+    predict_times = jnp.array([0.0, 1.0, 2.0, 3.0])
+    ctrl_times = predict_times[:-1]
+    ctrl_values = jnp.array([[1.0], [2.0], [3.0]])
+
+    result = dsx.DiscreteTimeSimulator().simulate(
+        _make_previous_transition_dynamics(),
+        rng_key=jr.PRNGKey(0),
+        predict_times=predict_times,
+        ctrl_times=ctrl_times,
+        ctrl_values=ctrl_values,
+    )
+
+    assert result.controls is not None
+    assert jnp.asarray(result.controls).shape == (1, 3, 1)
+    assert jnp.array_equal(jnp.asarray(result.controls)[0], ctrl_values)
+
+
+def test_discrete_simulator_controls_none_when_uncontrolled():
+    predict_times = jnp.arange(4.0)
+
+    result = dsx.simulate(
+        _make_discrete_dynamics(),
+        rng_key=jr.PRNGKey(0),
+        predict_times=predict_times,
+    )
+
+    assert result.controls is None

From b8e73fa883579163d7f1c19505c5cc740cbe6b62 Mon Sep 17 00:00:00 2001
From: Matthieu Darcy <68646255+MatthieuDarcy@users.noreply.github.com>
Date: Mon, 31 Aug 2026 14:26:03 -0400
Subject: [PATCH 3/8] Update discrete.py

Simplified docstring
---
 dynestyx/simulation/discrete.py | 53 ++-------------------------------
 1 file changed, 3 insertions(+), 50 deletions(-)

diff --git a/dynestyx/simulation/discrete.py b/dynestyx/simulation/discrete.py
index 21456dc9..232f075d 100644
--- a/dynestyx/simulation/discrete.py
+++ b/dynestyx/simulation/discrete.py
@@ -54,17 +54,6 @@ def _sample_discrete_state_path_from_initial_state(
     | None,
 ) -> Real[Array, "time state_dim"] | Real[Array, " time"]:
     """Sample one canonical discrete state path from a fixed initial state.
-
-    Always returns x_0..x_{T-1} (length T, matching `times`) -- x_0 is
-    included regardless of `dynamics.observation_control_alignment`; only
-    observation sampling (see `_simulate_forward_from_initial_state`) differs
-    by convention.
-
-    ctrl_values has its own length ("ctrl_time"), decoupled from `times`: it
-    is len(times) for same_time (one entry per transition plus one unused by
-    any transition, reserved for the final same_time observation) or
-    len(times) - 1 for previous_transition (exactly one entry per
-    transition).
     """
     if len(times) == 1:
         return jnp.expand_dims(initial_state, axis=0)
@@ -125,45 +114,9 @@ class DiscreteTimeSimulator(BaseSimulator):
     `n_simulations` independent paths. The observation/control pairing
     depends on `dynamics.observation_control_alignment`:
 
-    For `"same_time"` (default):
-
-    \[
-    x_0^{(m)} \sim p_0(x_0), \qquad
-    x_{k+1}^{(m)}
-      \sim p\!\left(x_{k+1}\mid x_k^{(m)},u_k,t_k,t_{k+1}\right),
-    \qquad
-    y_k^{(m)} \sim p(y_k\mid x_k^{(m)},u_k,t_k).
-    \]
-
-    The first state in the returned path is the initial-condition draw at
-    `predict_times[0]`; the simulator then makes one transition draw for each
-    adjacent pair of prediction times and samples one observation conditional
-    on every realized state, including \(y_0\) (paired with \(u_0\)).
-
-    For `"previous_transition"`:
-
-    \[
-    x_0^{(m)} \sim p_0(x_0), \qquad
-    x_{k+1}^{(m)} \sim p\!\left(x_{k+1}\mid x_k^{(m)},u_k,t_k,t_{k+1}\right),
-    \qquad
-    y_{k+1}^{(m)} \sim p(y_{k+1}\mid x_{k+1}^{(m)},u_k,t_{k+1}).
-    \]
-
-    Here \(y_0\) is never sampled -- there's no control that produced it --
-    but \(x_0\) is still part of the returned result, exactly like
-    `"same_time"`: `SimulatedResult.x_0` is populated and `.states` has length
-    \(T\) (matching `.times`/`predict_times`, \(x_0,\ldots,x_{T-1}\)).
-    `.observations` and `.controls`, however, are one shorter -- length
-    \(T-1\): \(y_1,\ldots,y_{T-1}\) and \(u_0,\ldots,u_{T-2}\) (aligned to
-    `predict_times[:-1]`, not the full `predict_times`). So `.states` is
-    intentionally one longer than `.observations`/`.controls`:
-    `states[k+1]` pairs with `observations[k]`/`controls[k]`, not
-    `states[k]`. This matches
-    [DiscreteControlLoopSimulator][dynestyx.control.discrete_controller_simulators.DiscreteControlLoopSimulator]'s
-    closed-loop convention. Only discrete-time models generated through the
-    plain `Simulator`/`DiscreteTimeSimulator`/`dsx.simulate` path honor this
-    convention today -- see
-    [issue #312](https://github.com/BasisResearch/dynestyx/issues/312).
+    For `"same_time"` (default): y_{k} is paired with u_{k} and x_{k} (including k=0). States, times, observations, and controls are all of length \(T\).
+    For `"previous_transition"`: y_{k+1} is paired with u_{k} and x_{k+1} (y_0 is never sampled). States and times are of length \(T\), but observations and controls are of length \(T-1\).
+
 
     See
     [DiscreteTimeStateEvolution][dynestyx.models.core.DiscreteTimeStateEvolution]

From bdacde1599bc825721de0ade34000f364e2f90eb Mon Sep 17 00:00:00 2001
From: Matthieu Darcy <68646255+MatthieuDarcy@users.noreply.github.com>
Date: Mon, 31 Aug 2026 14:29:39 -0400
Subject: [PATCH 4/8] Update discrete.py

---
 dynestyx/simulation/discrete.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/dynestyx/simulation/discrete.py b/dynestyx/simulation/discrete.py
index 232f075d..fa9ce445 100644
--- a/dynestyx/simulation/discrete.py
+++ b/dynestyx/simulation/discrete.py
@@ -53,8 +53,7 @@ def _sample_discrete_state_path_from_initial_state(
     | Real[Array, " ctrl_time"]
     | None,
 ) -> Real[Array, "time state_dim"] | Real[Array, " time"]:
-    """Sample one canonical discrete state path from a fixed initial state.
-    """
+    """Sample one canonical discrete state path from a fixed initial state."""
     if len(times) == 1:
         return jnp.expand_dims(initial_state, axis=0)
 

From 2f7483ba4c1a5953e04402bcbe6480304cf28544 Mon Sep 17 00:00:00 2001
From: Matthieu Darcy <68646255+MatthieuDarcy@users.noreply.github.com>
Date: Mon, 31 Aug 2026 16:55:40 -0400
Subject: [PATCH 5/8] Fixed MPPI

MPPI now uses the `previous_transition` convention from `dsx.simulate` directly.

The implementation is now mathemaitcally  correct: it does not duplicate control.

The initial state $x_0$ or the initial observation $y_0$ are not present in the `SimulatedResult` `states` and `observations` but $x_0$ is available through `res.x_0`.
---
 docs/tutorials/control/mpc_demo.ipynb |  39 +++++++---
 dynestyx/control/mppi.py              | 101 +++++++++++++++-----------
 tests/test_discrete_control.py        |  59 +++++++++++++++
 3 files changed, 147 insertions(+), 52 deletions(-)

diff --git a/docs/tutorials/control/mpc_demo.ipynb b/docs/tutorials/control/mpc_demo.ipynb
index aae2f9e3..63592142 100644
--- a/docs/tutorials/control/mpc_demo.ipynb
+++ b/docs/tutorials/control/mpc_demo.ipynb
@@ -25,7 +25,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 15,
    "id": "ccd86c86",
    "metadata": {
     "execution": {
@@ -72,7 +72,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 16,
    "id": "8fb57ad7",
    "metadata": {
     "execution": {
@@ -95,7 +95,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 17,
    "id": "2a43e151",
    "metadata": {
     "execution": {
@@ -149,7 +149,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 18,
    "id": "4e73ca0a",
    "metadata": {
     "execution": {
@@ -195,7 +195,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 19,
    "id": "0fc2b864",
    "metadata": {
     "execution": {
@@ -211,14 +211,14 @@
     "\n",
     "\n",
     "def quadratic_loss(result):  # drives the state to zero while penalizing control effort\n",
-    "    loss = jnp.sum(result.states[0, 1:]**2) # we remove the first state (initial condition)\n",
+    "    loss = jnp.sum(result.states[0]**2)  # states already exclude the initial condition\n",
     "    loss+= 0.01 * jnp.sum(result.controls[0]**2)\n",
     "    return loss"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 20,
    "id": "a603e321",
    "metadata": {
     "execution": {
@@ -265,6 +265,27 @@
     ")"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "cf44cfe6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'same_time'"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "nonlinear_dynamics.observation_control_alignment"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "658796bb",
@@ -275,7 +296,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 24,
    "id": "5dbcf7d2",
    "metadata": {
     "execution": {
@@ -288,7 +309,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x900 with 3 Axes>"
       ]
diff --git a/dynestyx/control/mppi.py b/dynestyx/control/mppi.py
index e2253b28..919d32f8 100644
--- a/dynestyx/control/mppi.py
+++ b/dynestyx/control/mppi.py
@@ -21,13 +21,13 @@
 from numpyro.distributions import Distribution
 
 import dynestyx as dsx
-from dynestyx.control.discrete_controller_simulators import ControlledSimulatedResult
 from dynestyx.models import DynamicalModel
+from dynestyx.types import SimulatedResult
 
-# (result: ControlledSimulatedResult) -> scalar, called once per sampled rollout
+# (result: SimulatedResult) -> scalar, called once per sampled rollout
 # (vmapped across all n_samples candidates) on that candidate's full rollout result.
 # See MPPI.loss_fn for the full shape contract.
-type MPPILossFn = Callable[[ControlledSimulatedResult], Real[Array, ""]]
+type MPPILossFn = Callable[[SimulatedResult], Real[Array, ""]]
 
 
 class MPPI(eqx.Module):
@@ -49,23 +49,31 @@ class MPPI(eqx.Module):
     step (receding horizon); the remainder becomes next step's nominal
     sequence, shifted left by one with the last entry repeated.
 
+    Each rollout is run under the `"previous_transition"` observation/
+    control convention, so a candidate's $u_k$ influences $x_{k+1}$ and
+    $y_{k+1}$. `dynamics` is copied (via `equinox.tree_at`) rather than modified, so the caller's
+    model keeps whatever `observation_control_alignment` it was built with.
+    See [Issue #312](https://github.com/BasisResearch/dynestyx/issues/312).
+
     Attributes:
         dynamics: a `DynamicalModel` (the same model used for the real simulation
             or some approximate). Each candidate rollout is computed by calling `dsx.simulate`.
             If `dynamics` holds trainable parameters you're also
             fitting via the outer simulation, they remain in the differentiable
             pytree so gradients through planning are tracked too.
-        loss_fn: `MPPILossFn`, i.e. `(result: ControlledSimulatedResult) -> scalar`,
+        loss_fn: `MPPILossFn`, i.e. `(result: SimulatedResult) -> scalar`,
             called once per sample (vmapped) on that candidate's full rollout. Every
             field carries a leading `n_simulations=1` axis -- e.g.
-            `result.states.shape == (1, horizon + 1, state_dim)` -- matching how
+            `result.states.shape == (1, horizon, state_dim)` -- matching how
             `dsx.simulate` never drops that axis, even for one trajectory;
             `jnp.sum(result.states**2)`-style reductions don't need to care, but
             explicit indexing does (`result.controls[0, 0]` is the whole first control
-            vector, not a scalar). `times`/`states`/`observations` have length
-            `horizon + 1` (including the starting state) and `controls` has length
-            `horizon`, matching `ControlledSimulatedResult`'s own
-            `control_time = time - 1` convention.
+            vector, not a scalar). `times`/`states`/`observations`/`controls` all
+            have length `horizon` and are index-aligned: at index `k`,
+            `states[k]` is $x_{k+1}$, `observations[k]` is $y_{k+1}$, and
+            `controls[k]` is $u_k$ -- the control that produced that state. The
+            starting state $x_0$ is not in `states` (no control produced it); it
+            is available separately as `result.x_0`, shape `(1, state_dim)`.
         horizon: Planning horizon length `H` -- the number of internal
             one-step `dynamics` calls per rollout. Defaults to `10`.
         noise_std: Standard deviation of the Gaussian perturbations added to
@@ -120,29 +128,26 @@ def _rollout_and_score_one(
         t_now: Real[Array, ""],
     ) -> tuple[
         Real[Array, ""],
-        Real[Array, "horizon+1 state_dim"],
-        Real[Array, "horizon+1 observation_dim"],
+        Real[Array, "horizon state_dim"],
+        Real[Array, "horizon observation_dim"],
     ]:
         """Roll out one candidate control sequence by calling `dsx.simulate`
         on a copy of `dynamics` pinned to start at `x0`, then score it with
-        `loss_fn`. Returns `(loss, states, observations)` -- plain arrays
-        only, since `ControlledSimulatedResult` isn't JAX-pytree-registered
-        and so can never itself cross a `vmap` boundary; it's built and fully
-        consumed here, inside the per-candidate function that gets vmapped."""
+        `loss_fn`.
+        Returns `(loss, states, observations)` -- plain arrays
+        only, since `SimulatedResult` isn't JAX-pytree-registered and so can
+        never itself cross a `vmap` boundary."""
         times = t_now + jnp.arange(self.horizon + 1) * self.dt  # (horizon+1,)
 
+        # Pin the rollout to start at x0, and plan under the  "previous_transition"
+        # convention so y_{k+1} is paired with u_k (the
+        # control that produced x_{k+1}) rather than with u_k at the same
+        # index.
         pinned_dynamics = eqx.tree_at(
-            lambda m: m.initial_condition,
+            lambda m: (m.initial_condition, m.observation_control_alignment),
             self.dynamics,
-            dist.Delta(x0, event_dim=1),
+            (dist.Delta(x0, event_dim=1), "previous_transition"),
         )
-        # dsx.simulate's same-index convention pairs ctrl_values[t] with both
-        # the transition from t and the observation at t, so it needs
-        # horizon+1 entries; u_seq only has horizon (one per transition).
-        # Pad with a repeat of the last control, used only to drive the final
-        # (never-transitioned-from) observation -- purely internal plumbing,
-        # never seen by loss_fn (which gets the real, unpadded u_seq below).
-        ctrl_padded = jnp.concatenate([u_seq, u_seq[-1:]], axis=0)
 
         # Relies on dsx.simulate's internals (Simulator/DiscreteTimeSimulator)
         # staying plain JAX array ops with no data-dependent Python branching,
@@ -151,21 +156,24 @@ def _rollout_and_score_one(
             pinned_dynamics,
             rng_key=key,
             predict_times=times,
-            ctrl_times=times,
-            ctrl_values=ctrl_padded,
+            ctrl_times=times[:-1],
+            ctrl_values=u_seq,
         )
         assert res.states is not None
         assert res.observations is not None
-        states = res.states[0]  # squeezed, for plan_step's own batching below
+        # Under previous_transition, dsx.simulate returns states of length
+        # horizon+1 (x_0..x_H) but observations/controls of length horizon.
+        # Drop x_0/t_0 so loss_fn sees four index-aligned length-horizon
+        # arrays: states[k]=x_{k+1}, observations[k]=y_{k+1}, controls[k]=u_k.
+        states = res.states[0][1:]  # squeezed, for plan_step's own batching
         observations = res.observations[0]
 
-        # ControlledSimulatedResult's fields all require a leading
-        # n_simulations axis (matching how dsx.simulate never drops it, even
-        # for one trajectory) -- so loss_fn sees the same n_simulations=1
-        # shape a real single dsx.simulate() call would produce, not a
-        # squeezed one.
-        result = ControlledSimulatedResult(
-            times=times[None],
+        # SimulatedResult's array fields all carry a leading n_simulations
+        # axis (matching how dsx.simulate never drops it, even for one
+        # trajectory) -- so loss_fn sees the same n_simulations=1 shape a real
+        # single dsx.simulate() call would produce, not a squeezed one.
+        result = SimulatedResult(
+            times=times[1:][None],
             x_0=x0[None],
             states=states[None],
             observations=observations[None],
@@ -181,20 +189,21 @@ def plan_step(
     ) -> tuple[
         Real[Array, " control_dim"],
         tuple[Real[Array, "horizon control_dim"], PRNGKeyArray],
-        ControlledSimulatedResult,
+        SimulatedResult,
     ]:
         """Do MPPI's full planning step and also return the batch of every
-        candidate rollout considered (`n_samples`-wide `ControlledSimulatedResult`)
+        candidate rollout considered (`n_samples`-wide `SimulatedResult`).
         -- useful for debugging/plotting what MPPI weighed, or diagnosing a
-        `loss_fn`. `__call__` (used by `DiscreteControlLoopSimulator`) is a
+        `loss_fn`.
+
+        `__call__` (used by `DiscreteControlLoopSimulator`) is a
         thin wrapper around this that drops the rollout batch, since
         `PolicyCallable`'s return signature can't carry a third value.
 
         Note: the returned result's leading axis indexes *candidates*, not
         independent draws from the true generative process -- it's not a
-        real simulated trajectory. `filtered_states_mean`/`policy_states`/
-        `predicted_*` are always `None` (not meaningful for a planning
-        rollout).
+        real simulated trajectory. `predicted_*` are always `None` (not
+        meaningful for a planning rollout).
         """
         x0 = x_hat.mean
         nominal, key = s
@@ -229,9 +238,15 @@ def plan_step(
         u0 = weighted_seq[0]
         next_nominal = jnp.concatenate([weighted_seq[1:], weighted_seq[-1:]], axis=0)
 
-        times = t_now + jnp.arange(self.horizon + 1) * self.dt
-        result = ControlledSimulatedResult(
-            times=jnp.broadcast_to(times, (self.n_samples, self.horizon + 1)),
+        # times[1:]: t_0 is dropped to match the horizon-length states/
+        # observations each rollout returns (see _rollout_and_score_one).
+        times = t_now + jnp.arange(1, self.horizon + 1) * self.dt
+
+        # This is a "fake" SimulatedResult, not a real simulated trajectory -- it's the
+        # batch of all candidate rollouts that were considered. This might change in the future, see issue #347.
+        # The leading axis indexes candidates, not independent draws from the true generative process.
+        result = SimulatedResult(
+            times=jnp.broadcast_to(times, (self.n_samples, self.horizon)),
             x_0=jnp.broadcast_to(x0, (self.n_samples,) + x0.shape),
             states=states_batch,
             observations=obs_batch,
diff --git a/tests/test_discrete_control.py b/tests/test_discrete_control.py
index bbc473ff..645867cc 100644
--- a/tests/test_discrete_control.py
+++ b/tests/test_discrete_control.py
@@ -1110,3 +1110,62 @@ def flaky_loss(result):
     )
     assert jnp.all(jnp.isfinite(u0))
     assert jnp.all(jnp.isfinite(next_nominal))
+
+
+def test_mppi_rollout_arrays_are_horizon_length_and_causally_aligned():
+    """MPPI plans under "previous_transition" (#312), so every rollout array
+    handed to loss_fn has length `horizon` and shares one index: states[k] is
+    x_{k+1}, observations[k] is y_{k+1}, controls[k] is u_k -- the control
+    that produced that state. x_0 is excluded from states (no control
+    produced it) and carried separately. The observation model here leaks
+    100*u into the mean so the pairing can be read straight off the output.
+    """
+    horizon = 3
+
+    def transition(x, u, t_now, t_next):
+        del t_now, t_next
+        u = jnp.zeros_like(x) if u is None else u
+        return dist.Delta(x + u).to_event(1)
+
+    def observation(x, u, t):
+        del t
+        u = jnp.zeros_like(x) if u is None else u
+        return dist.Delta(x + 100.0 * u).to_event(1)
+
+    dynamics = DynamicalModel(
+        initial_condition=dist.Delta(jnp.zeros(1)).to_event(1),
+        state_evolution=transition,
+        observation_model=observation,
+        control_dim=1,
+    )
+    mppi = MPPI(
+        dynamics=dynamics,
+        loss_fn=lambda result: jnp.sum(result.states**2),
+        horizon=horizon,
+        n_samples=1,
+        noise_std=jnp.array(0.0),  # candidate == nominal, so u is exactly known
+    )
+
+    nominal = jnp.array([[1.0], [2.0], [3.0]])
+    _, _, result = mppi.plan_step(
+        dist.Delta(jnp.zeros(1)).to_event(1),
+        jnp.array(0.0),
+        (nominal, jr.PRNGKey(0)),
+    )
+
+    # Plain SimulatedResult now carries the controls; no ControlledSimulatedResult.
+    assert result.times is not None
+    assert result.states is not None
+    assert result.observations is not None
+    assert result.controls is not None
+    assert result.x_0 is not None
+    for arr in (result.times, result.states, result.observations, result.controls):
+        assert arr.shape[1] == horizon
+
+    states, observations = result.states[0], result.observations[0]
+    controls = result.controls[0]
+    # x_0 = 0 is excluded: states start at x_1 = u_0 = 1.
+    assert jnp.allclose(states, jnp.array([[1.0], [3.0], [6.0]]))
+    assert jnp.allclose(result.x_0[0], jnp.zeros(1))
+    # Each observation reveals the control that produced its state: u_k, not u_{k+1}.
+    assert jnp.allclose((observations - states) / 100.0, controls)

From d7dd1078c73e9bcff13da17b703194a66b538047 Mon Sep 17 00:00:00 2001
From: Matthieu Darcy <68646255+MatthieuDarcy@users.noreply.github.com>
Date: Mon, 31 Aug 2026 16:55:40 -0400
Subject: [PATCH 6/8] Fixed MPPI

MPPI now uses the `previous_transition` convention from `dsx.simulate` directly.

The implementation is now mathemaitcally  correct: it does not duplicate control.

The initial state $x_0$ or the initial observation $y_0$ are not present in the `SimulatedResult` `states` and `observations` but $x_0$ is available through `res.x_0`.
---
 docs/tutorials/control/mpc_demo.ipynb |  39 +++++++---
 dynestyx/control/mppi.py              | 101 +++++++++++++++-----------
 tests/test_discrete_control.py        |  59 +++++++++++++++
 3 files changed, 147 insertions(+), 52 deletions(-)

diff --git a/docs/tutorials/control/mpc_demo.ipynb b/docs/tutorials/control/mpc_demo.ipynb
index aae2f9e3..63592142 100644
--- a/docs/tutorials/control/mpc_demo.ipynb
+++ b/docs/tutorials/control/mpc_demo.ipynb
@@ -25,7 +25,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 15,
    "id": "ccd86c86",
    "metadata": {
     "execution": {
@@ -72,7 +72,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 16,
    "id": "8fb57ad7",
    "metadata": {
     "execution": {
@@ -95,7 +95,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 17,
    "id": "2a43e151",
    "metadata": {
     "execution": {
@@ -149,7 +149,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 18,
    "id": "4e73ca0a",
    "metadata": {
     "execution": {
@@ -195,7 +195,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 19,
    "id": "0fc2b864",
    "metadata": {
     "execution": {
@@ -211,14 +211,14 @@
     "\n",
     "\n",
     "def quadratic_loss(result):  # drives the state to zero while penalizing control effort\n",
-    "    loss = jnp.sum(result.states[0, 1:]**2) # we remove the first state (initial condition)\n",
+    "    loss = jnp.sum(result.states[0]**2)  # states already exclude the initial condition\n",
     "    loss+= 0.01 * jnp.sum(result.controls[0]**2)\n",
     "    return loss"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 20,
    "id": "a603e321",
    "metadata": {
     "execution": {
@@ -265,6 +265,27 @@
     ")"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "cf44cfe6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'same_time'"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "nonlinear_dynamics.observation_control_alignment"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "658796bb",
@@ -275,7 +296,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 24,
    "id": "5dbcf7d2",
    "metadata": {
     "execution": {
@@ -288,7 +309,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x900 with 3 Axes>"
       ]
diff --git a/dynestyx/control/mppi.py b/dynestyx/control/mppi.py
index e2253b28..919d32f8 100644
--- a/dynestyx/control/mppi.py
+++ b/dynestyx/control/mppi.py
@@ -21,13 +21,13 @@
 from numpyro.distributions import Distribution
 
 import dynestyx as dsx
-from dynestyx.control.discrete_controller_simulators import ControlledSimulatedResult
 from dynestyx.models import DynamicalModel
+from dynestyx.types import SimulatedResult
 
-# (result: ControlledSimulatedResult) -> scalar, called once per sampled rollout
+# (result: SimulatedResult) -> scalar, called once per sampled rollout
 # (vmapped across all n_samples candidates) on that candidate's full rollout result.
 # See MPPI.loss_fn for the full shape contract.
-type MPPILossFn = Callable[[ControlledSimulatedResult], Real[Array, ""]]
+type MPPILossFn = Callable[[SimulatedResult], Real[Array, ""]]
 
 
 class MPPI(eqx.Module):
@@ -49,23 +49,31 @@ class MPPI(eqx.Module):
     step (receding horizon); the remainder becomes next step's nominal
     sequence, shifted left by one with the last entry repeated.
 
+    Each rollout is run under the `"previous_transition"` observation/
+    control convention, so a candidate's $u_k$ influences $x_{k+1}$ and
+    $y_{k+1}$. `dynamics` is copied (via `equinox.tree_at`) rather than modified, so the caller's
+    model keeps whatever `observation_control_alignment` it was built with.
+    See [Issue #312](https://github.com/BasisResearch/dynestyx/issues/312).
+
     Attributes:
         dynamics: a `DynamicalModel` (the same model used for the real simulation
             or some approximate). Each candidate rollout is computed by calling `dsx.simulate`.
             If `dynamics` holds trainable parameters you're also
             fitting via the outer simulation, they remain in the differentiable
             pytree so gradients through planning are tracked too.
-        loss_fn: `MPPILossFn`, i.e. `(result: ControlledSimulatedResult) -> scalar`,
+        loss_fn: `MPPILossFn`, i.e. `(result: SimulatedResult) -> scalar`,
             called once per sample (vmapped) on that candidate's full rollout. Every
             field carries a leading `n_simulations=1` axis -- e.g.
-            `result.states.shape == (1, horizon + 1, state_dim)` -- matching how
+            `result.states.shape == (1, horizon, state_dim)` -- matching how
             `dsx.simulate` never drops that axis, even for one trajectory;
             `jnp.sum(result.states**2)`-style reductions don't need to care, but
             explicit indexing does (`result.controls[0, 0]` is the whole first control
-            vector, not a scalar). `times`/`states`/`observations` have length
-            `horizon + 1` (including the starting state) and `controls` has length
-            `horizon`, matching `ControlledSimulatedResult`'s own
-            `control_time = time - 1` convention.
+            vector, not a scalar). `times`/`states`/`observations`/`controls` all
+            have length `horizon` and are index-aligned: at index `k`,
+            `states[k]` is $x_{k+1}$, `observations[k]` is $y_{k+1}$, and
+            `controls[k]` is $u_k$ -- the control that produced that state. The
+            starting state $x_0$ is not in `states` (no control produced it); it
+            is available separately as `result.x_0`, shape `(1, state_dim)`.
         horizon: Planning horizon length `H` -- the number of internal
             one-step `dynamics` calls per rollout. Defaults to `10`.
         noise_std: Standard deviation of the Gaussian perturbations added to
@@ -120,29 +128,26 @@ def _rollout_and_score_one(
         t_now: Real[Array, ""],
     ) -> tuple[
         Real[Array, ""],
-        Real[Array, "horizon+1 state_dim"],
-        Real[Array, "horizon+1 observation_dim"],
+        Real[Array, "horizon state_dim"],
+        Real[Array, "horizon observation_dim"],
     ]:
         """Roll out one candidate control sequence by calling `dsx.simulate`
         on a copy of `dynamics` pinned to start at `x0`, then score it with
-        `loss_fn`. Returns `(loss, states, observations)` -- plain arrays
-        only, since `ControlledSimulatedResult` isn't JAX-pytree-registered
-        and so can never itself cross a `vmap` boundary; it's built and fully
-        consumed here, inside the per-candidate function that gets vmapped."""
+        `loss_fn`.
+        Returns `(loss, states, observations)` -- plain arrays
+        only, since `SimulatedResult` isn't JAX-pytree-registered and so can
+        never itself cross a `vmap` boundary."""
         times = t_now + jnp.arange(self.horizon + 1) * self.dt  # (horizon+1,)
 
+        # Pin the rollout to start at x0, and plan under the  "previous_transition"
+        # convention so y_{k+1} is paired with u_k (the
+        # control that produced x_{k+1}) rather than with u_k at the same
+        # index.
         pinned_dynamics = eqx.tree_at(
-            lambda m: m.initial_condition,
+            lambda m: (m.initial_condition, m.observation_control_alignment),
             self.dynamics,
-            dist.Delta(x0, event_dim=1),
+            (dist.Delta(x0, event_dim=1), "previous_transition"),
         )
-        # dsx.simulate's same-index convention pairs ctrl_values[t] with both
-        # the transition from t and the observation at t, so it needs
-        # horizon+1 entries; u_seq only has horizon (one per transition).
-        # Pad with a repeat of the last control, used only to drive the final
-        # (never-transitioned-from) observation -- purely internal plumbing,
-        # never seen by loss_fn (which gets the real, unpadded u_seq below).
-        ctrl_padded = jnp.concatenate([u_seq, u_seq[-1:]], axis=0)
 
         # Relies on dsx.simulate's internals (Simulator/DiscreteTimeSimulator)
         # staying plain JAX array ops with no data-dependent Python branching,
@@ -151,21 +156,24 @@ def _rollout_and_score_one(
             pinned_dynamics,
             rng_key=key,
             predict_times=times,
-            ctrl_times=times,
-            ctrl_values=ctrl_padded,
+            ctrl_times=times[:-1],
+            ctrl_values=u_seq,
         )
         assert res.states is not None
         assert res.observations is not None
-        states = res.states[0]  # squeezed, for plan_step's own batching below
+        # Under previous_transition, dsx.simulate returns states of length
+        # horizon+1 (x_0..x_H) but observations/controls of length horizon.
+        # Drop x_0/t_0 so loss_fn sees four index-aligned length-horizon
+        # arrays: states[k]=x_{k+1}, observations[k]=y_{k+1}, controls[k]=u_k.
+        states = res.states[0][1:]  # squeezed, for plan_step's own batching
         observations = res.observations[0]
 
-        # ControlledSimulatedResult's fields all require a leading
-        # n_simulations axis (matching how dsx.simulate never drops it, even
-        # for one trajectory) -- so loss_fn sees the same n_simulations=1
-        # shape a real single dsx.simulate() call would produce, not a
-        # squeezed one.
-        result = ControlledSimulatedResult(
-            times=times[None],
+        # SimulatedResult's array fields all carry a leading n_simulations
+        # axis (matching how dsx.simulate never drops it, even for one
+        # trajectory) -- so loss_fn sees the same n_simulations=1 shape a real
+        # single dsx.simulate() call would produce, not a squeezed one.
+        result = SimulatedResult(
+            times=times[1:][None],
             x_0=x0[None],
             states=states[None],
             observations=observations[None],
@@ -181,20 +189,21 @@ def plan_step(
     ) -> tuple[
         Real[Array, " control_dim"],
         tuple[Real[Array, "horizon control_dim"], PRNGKeyArray],
-        ControlledSimulatedResult,
+        SimulatedResult,
     ]:
         """Do MPPI's full planning step and also return the batch of every
-        candidate rollout considered (`n_samples`-wide `ControlledSimulatedResult`)
+        candidate rollout considered (`n_samples`-wide `SimulatedResult`).
         -- useful for debugging/plotting what MPPI weighed, or diagnosing a
-        `loss_fn`. `__call__` (used by `DiscreteControlLoopSimulator`) is a
+        `loss_fn`.
+
+        `__call__` (used by `DiscreteControlLoopSimulator`) is a
         thin wrapper around this that drops the rollout batch, since
         `PolicyCallable`'s return signature can't carry a third value.
 
         Note: the returned result's leading axis indexes *candidates*, not
         independent draws from the true generative process -- it's not a
-        real simulated trajectory. `filtered_states_mean`/`policy_states`/
-        `predicted_*` are always `None` (not meaningful for a planning
-        rollout).
+        real simulated trajectory. `predicted_*` are always `None` (not
+        meaningful for a planning rollout).
         """
         x0 = x_hat.mean
         nominal, key = s
@@ -229,9 +238,15 @@ def plan_step(
         u0 = weighted_seq[0]
         next_nominal = jnp.concatenate([weighted_seq[1:], weighted_seq[-1:]], axis=0)
 
-        times = t_now + jnp.arange(self.horizon + 1) * self.dt
-        result = ControlledSimulatedResult(
-            times=jnp.broadcast_to(times, (self.n_samples, self.horizon + 1)),
+        # times[1:]: t_0 is dropped to match the horizon-length states/
+        # observations each rollout returns (see _rollout_and_score_one).
+        times = t_now + jnp.arange(1, self.horizon + 1) * self.dt
+
+        # This is a "fake" SimulatedResult, not a real simulated trajectory -- it's the
+        # batch of all candidate rollouts that were considered. This might change in the future, see issue #347.
+        # The leading axis indexes candidates, not independent draws from the true generative process.
+        result = SimulatedResult(
+            times=jnp.broadcast_to(times, (self.n_samples, self.horizon)),
             x_0=jnp.broadcast_to(x0, (self.n_samples,) + x0.shape),
             states=states_batch,
             observations=obs_batch,
diff --git a/tests/test_discrete_control.py b/tests/test_discrete_control.py
index bbc473ff..645867cc 100644
--- a/tests/test_discrete_control.py
+++ b/tests/test_discrete_control.py
@@ -1110,3 +1110,62 @@ def flaky_loss(result):
     )
     assert jnp.all(jnp.isfinite(u0))
     assert jnp.all(jnp.isfinite(next_nominal))
+
+
+def test_mppi_rollout_arrays_are_horizon_length_and_causally_aligned():
+    """MPPI plans under "previous_transition" (#312), so every rollout array
+    handed to loss_fn has length `horizon` and shares one index: states[k] is
+    x_{k+1}, observations[k] is y_{k+1}, controls[k] is u_k -- the control
+    that produced that state. x_0 is excluded from states (no control
+    produced it) and carried separately. The observation model here leaks
+    100*u into the mean so the pairing can be read straight off the output.
+    """
+    horizon = 3
+
+    def transition(x, u, t_now, t_next):
+        del t_now, t_next
+        u = jnp.zeros_like(x) if u is None else u
+        return dist.Delta(x + u).to_event(1)
+
+    def observation(x, u, t):
+        del t
+        u = jnp.zeros_like(x) if u is None else u
+        return dist.Delta(x + 100.0 * u).to_event(1)
+
+    dynamics = DynamicalModel(
+        initial_condition=dist.Delta(jnp.zeros(1)).to_event(1),
+        state_evolution=transition,
+        observation_model=observation,
+        control_dim=1,
+    )
+    mppi = MPPI(
+        dynamics=dynamics,
+        loss_fn=lambda result: jnp.sum(result.states**2),
+        horizon=horizon,
+        n_samples=1,
+        noise_std=jnp.array(0.0),  # candidate == nominal, so u is exactly known
+    )
+
+    nominal = jnp.array([[1.0], [2.0], [3.0]])
+    _, _, result = mppi.plan_step(
+        dist.Delta(jnp.zeros(1)).to_event(1),
+        jnp.array(0.0),
+        (nominal, jr.PRNGKey(0)),
+    )
+
+    # Plain SimulatedResult now carries the controls; no ControlledSimulatedResult.
+    assert result.times is not None
+    assert result.states is not None
+    assert result.observations is not None
+    assert result.controls is not None
+    assert result.x_0 is not None
+    for arr in (result.times, result.states, result.observations, result.controls):
+        assert arr.shape[1] == horizon
+
+    states, observations = result.states[0], result.observations[0]
+    controls = result.controls[0]
+    # x_0 = 0 is excluded: states start at x_1 = u_0 = 1.
+    assert jnp.allclose(states, jnp.array([[1.0], [3.0], [6.0]]))
+    assert jnp.allclose(result.x_0[0], jnp.zeros(1))
+    # Each observation reveals the control that produced its state: u_k, not u_{k+1}.
+    assert jnp.allclose((observations - states) / 100.0, controls)

From ea0785b3974af9dd2407ead1824024adc5bc7690 Mon Sep 17 00:00:00 2001
From: Matthieu Darcy <68646255+MatthieuDarcy@users.noreply.github.com>
Date: Tue, 1 Sep 2026 10:32:54 -0400
Subject: [PATCH 7/8] Updated results used by MPPI

MPPI now uses vmap over controls
---
 docs/tutorials/control/mpc_demo.ipynb | 25 +++++----
 dynestyx/control/mppi.py              | 81 +++++++++------------------
 tests/test_discrete_control.py        | 36 ++++++++++--
 3 files changed, 73 insertions(+), 69 deletions(-)

diff --git a/docs/tutorials/control/mpc_demo.ipynb b/docs/tutorials/control/mpc_demo.ipynb
index 63592142..6b91dd37 100644
--- a/docs/tutorials/control/mpc_demo.ipynb
+++ b/docs/tutorials/control/mpc_demo.ipynb
@@ -25,7 +25,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 1,
    "id": "ccd86c86",
    "metadata": {
     "execution": {
@@ -72,7 +72,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 2,
    "id": "8fb57ad7",
    "metadata": {
     "execution": {
@@ -95,7 +95,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 3,
    "id": "2a43e151",
    "metadata": {
     "execution": {
@@ -149,7 +149,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 4,
    "id": "4e73ca0a",
    "metadata": {
     "execution": {
@@ -195,7 +195,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "id": "0fc2b864",
    "metadata": {
     "execution": {
@@ -211,14 +211,14 @@
     "\n",
     "\n",
     "def quadratic_loss(result):  # drives the state to zero while penalizing control effort\n",
-    "    loss = jnp.sum(result.states[0]**2)  # states already exclude the initial condition\n",
-    "    loss+= 0.01 * jnp.sum(result.controls[0]**2)\n",
+    "    loss = jnp.mean(result.states**2)  # states of shape (n_simulations, horizon, state_dim) by default, already exclude the initial condition\n",
+    "    loss+= 0.01 * jnp.mean(result.controls**2)\n",
     "    return loss"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 7,
    "id": "a603e321",
    "metadata": {
     "execution": {
@@ -239,6 +239,7 @@
     "    loss_fn=quadratic_loss,\n",
     "    horizon=horizon,\n",
     "    n_samples=n_samples,\n",
+    "    n_simulations = 1, # how many simulations to run in parallel for each control step (default 1)\n",
     ")\n",
     "\n",
     "key_2d = jr.PRNGKey(0)\n",
@@ -267,7 +268,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 8,
    "id": "cf44cfe6",
    "metadata": {},
    "outputs": [
@@ -277,7 +278,7 @@
        "'same_time'"
       ]
      },
-     "execution_count": 25,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -296,7 +297,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 9,
    "id": "5dbcf7d2",
    "metadata": {
     "execution": {
@@ -309,7 +310,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x900 with 3 Axes>"
       ]
diff --git a/dynestyx/control/mppi.py b/dynestyx/control/mppi.py
index 919d32f8..fc964ef8 100644
--- a/dynestyx/control/mppi.py
+++ b/dynestyx/control/mppi.py
@@ -63,12 +63,9 @@ class MPPI(eqx.Module):
             pytree so gradients through planning are tracked too.
         loss_fn: `MPPILossFn`, i.e. `(result: SimulatedResult) -> scalar`,
             called once per sample (vmapped) on that candidate's full rollout. Every
-            field carries a leading `n_simulations=1` axis -- e.g.
-            `result.states.shape == (1, horizon, state_dim)` -- matching how
-            `dsx.simulate` never drops that axis, even for one trajectory;
-            `jnp.sum(result.states**2)`-style reductions don't need to care, but
-            explicit indexing does (`result.controls[0, 0]` is the whole first control
-            vector, not a scalar). `times`/`states`/`observations`/`controls` all
+            field carries a leading `n_simulations` axis -- e.g.
+            `result.states.shape == (n_simulations, horizon, state_dim)`, so
+            `(1, horizon, state_dim)` by default. `times`/`states`/`observations`/`controls` all
             have length `horizon` and are index-aligned: at index `k`,
             `states[k]` is $x_{k+1}$, `observations[k]` is $y_{k+1}$, and
             `controls[k]` is $u_k$ -- the control that produced that state. The
@@ -81,6 +78,8 @@ class MPPI(eqx.Module):
             to `1.0`.
         n_samples: Number of sampled control sequences per call. Defaults to
             `20`.
+        n_simulations: Number of independent rollouts drawn per candidate
+            control sequence, forwarded to `dsx.simulate`. Defaults to `1`.
         dt: Fixed planning step size. Defaults to `1.0`.
         temperature: MPPI's $\\lambda$; higher values flatten the weights
             toward a uniform average, lower values concentrate weight on the
@@ -103,6 +102,7 @@ class MPPI(eqx.Module):
         default_factory=lambda: jnp.array(1.0)
     )
     n_samples: int = eqx.field(static=True, default=20)
+    n_simulations: int = eqx.field(static=True, default=1)
     dt: float = eqx.field(static=True, default=1.0)
     temperature: float = 1.0
     batched: bool = eqx.field(static=True, default=True)
@@ -126,17 +126,12 @@ def _rollout_and_score_one(
         u_seq: Real[Array, "horizon control_dim"],
         key: PRNGKeyArray,
         t_now: Real[Array, ""],
-    ) -> tuple[
-        Real[Array, ""],
-        Real[Array, "horizon state_dim"],
-        Real[Array, "horizon observation_dim"],
-    ]:
+    ) -> tuple[Real[Array, ""], SimulatedResult]:
         """Roll out one candidate control sequence by calling `dsx.simulate`
         on a copy of `dynamics` pinned to start at `x0`, then score it with
         `loss_fn`.
-        Returns `(loss, states, observations)` -- plain arrays
-        only, since `SimulatedResult` isn't JAX-pytree-registered and so can
-        never itself cross a `vmap` boundary."""
+
+        Returns `(loss, result)`."""
         times = t_now + jnp.arange(self.horizon + 1) * self.dt  # (horizon+1,)
 
         # Pin the rollout to start at x0, and plan under the  "previous_transition"
@@ -158,28 +153,24 @@ def _rollout_and_score_one(
             predict_times=times,
             ctrl_times=times[:-1],
             ctrl_values=u_seq,
+            n_simulations=self.n_simulations,
         )
+        assert res.times is not None
         assert res.states is not None
-        assert res.observations is not None
-        # Under previous_transition, dsx.simulate returns states of length
-        # horizon+1 (x_0..x_H) but observations/controls of length horizon.
-        # Drop x_0/t_0 so loss_fn sees four index-aligned length-horizon
-        # arrays: states[k]=x_{k+1}, observations[k]=y_{k+1}, controls[k]=u_k.
-        states = res.states[0][1:]  # squeezed, for plan_step's own batching
-        observations = res.observations[0]
-
-        # SimulatedResult's array fields all carry a leading n_simulations
-        # axis (matching how dsx.simulate never drops it, even for one
-        # trajectory) -- so loss_fn sees the same n_simulations=1 shape a real
-        # single dsx.simulate() call would produce, not a squeezed one.
+        # Under previous_transition, dsx.simulate returns times/states of
+        # length horizon+1 (t_0..t_H, x_0..x_H) but observations/controls of
+        # length horizon. Drop t_0/x_0 so loss_fn sees four index-aligned
+        # length-horizon arrays: states[k]=x_{k+1}, observations[k]=y_{k+1},
+        # controls[k]=u_k. Everything else is passed through from `res`
+        # unchanged, so each field keeps its leading n_simulations axis.
         result = SimulatedResult(
-            times=times[1:][None],
-            x_0=x0[None],
-            states=states[None],
-            observations=observations[None],
-            controls=u_seq[None],
+            times=res.times[:, 1:],
+            x_0=res.x_0,
+            states=res.states[:, 1:],  # drop x_0
+            observations=res.observations,
+            controls=res.controls,
         )
-        return self.loss_fn(result), states, observations
+        return self.loss_fn(result), result
 
     def plan_step(
         self,
@@ -200,10 +191,8 @@ def plan_step(
         thin wrapper around this that drops the rollout batch, since
         `PolicyCallable`'s return signature can't carry a third value.
 
-        Note: the returned result's leading axis indexes *candidates*, not
-        independent draws from the true generative process -- it's not a
-        real simulated trajectory. `predicted_*` are always `None` (not
-        meaningful for a planning rollout).
+        Every field is shaped `(n_samples, n_simulations, horizon, ...)`.
+        `predicted_*` are always `None` (not meaningful for a planning rollout).
         """
         x0 = x_hat.mean
         nominal, key = s
@@ -219,11 +208,11 @@ def plan_step(
         rollout_keys = jr.split(rollout_key, self.n_samples)
 
         if self.batched:
-            losses, states_batch, obs_batch = jax.vmap(
+            losses, rollouts = jax.vmap(
                 self._rollout_and_score_one, in_axes=(None, 0, 0, None)
             )(x0, control_candidates, rollout_keys, t_now)
         else:
-            losses, states_batch, obs_batch = jax.lax.map(
+            losses, rollouts = jax.lax.map(
                 lambda args: self._rollout_and_score_one(x0, args[0], args[1], t_now),
                 (control_candidates, rollout_keys),
             )
@@ -238,21 +227,7 @@ def plan_step(
         u0 = weighted_seq[0]
         next_nominal = jnp.concatenate([weighted_seq[1:], weighted_seq[-1:]], axis=0)
 
-        # times[1:]: t_0 is dropped to match the horizon-length states/
-        # observations each rollout returns (see _rollout_and_score_one).
-        times = t_now + jnp.arange(1, self.horizon + 1) * self.dt
-
-        # This is a "fake" SimulatedResult, not a real simulated trajectory -- it's the
-        # batch of all candidate rollouts that were considered. This might change in the future, see issue #347.
-        # The leading axis indexes candidates, not independent draws from the true generative process.
-        result = SimulatedResult(
-            times=jnp.broadcast_to(times, (self.n_samples, self.horizon)),
-            x_0=jnp.broadcast_to(x0, (self.n_samples,) + x0.shape),
-            states=states_batch,
-            observations=obs_batch,
-            controls=control_candidates,
-        )
-        return u0, (next_nominal, key), result
+        return u0, (next_nominal, key), rollouts
 
     def __call__(
         self,
diff --git a/tests/test_discrete_control.py b/tests/test_discrete_control.py
index 645867cc..478fcea7 100644
--- a/tests/test_discrete_control.py
+++ b/tests/test_discrete_control.py
@@ -1159,13 +1159,41 @@ def observation(x, u, t):
     assert result.observations is not None
     assert result.controls is not None
     assert result.x_0 is not None
+    # (n_samples, n_simulations, horizon, ...) -- n_simulations defaults to 1.
     for arr in (result.times, result.states, result.observations, result.controls):
-        assert arr.shape[1] == horizon
+        assert arr.shape[:3] == (1, 1, horizon)
 
-    states, observations = result.states[0], result.observations[0]
-    controls = result.controls[0]
+    states, observations = result.states[0, 0], result.observations[0, 0]
+    controls = result.controls[0, 0]
     # x_0 = 0 is excluded: states start at x_1 = u_0 = 1.
     assert jnp.allclose(states, jnp.array([[1.0], [3.0], [6.0]]))
-    assert jnp.allclose(result.x_0[0], jnp.zeros(1))
+    assert jnp.allclose(result.x_0[0, 0], jnp.zeros(1))
     # Each observation reveals the control that produced its state: u_k, not u_{k+1}.
     assert jnp.allclose((observations - states) / 100.0, controls)
+
+
+def test_mppi_n_simulations_draws_independent_rollouts_per_candidate():
+    """n_simulations>1 runs several rollouts per candidate, so plan_step's
+    batch is (n_samples, n_simulations, horizon, ...). The candidate's control
+    sequence is shared across its draws; only the sampled dynamics differ."""
+    n_samples, n_simulations, horizon = 5, 4, 3
+    dynamics = _lti_1d(A=1.05, B=1.0, Q=0.25)
+    mppi = MPPI(
+        dynamics=dynamics,
+        loss_fn=lambda result: jnp.mean(jnp.sum(result.states**2, axis=(-2, -1))),
+        horizon=horizon,
+        n_samples=n_samples,
+        n_simulations=n_simulations,
+    )
+
+    _, _, result = mppi.plan_step(
+        dist.MultivariateNormal(jnp.array([2.0]), jnp.eye(1)),
+        jnp.array(0.0),
+        mppi.initial_state(),
+    )
+
+    assert result.states is not None
+    assert result.controls is not None
+    assert result.states.shape[:3] == (n_samples, n_simulations, horizon)
+    assert result.controls.shape[:3] == (n_samples, n_simulations, horizon)
+

From 65835992f9a2dd3f674829db3b28a50cb0beae15 Mon Sep 17 00:00:00 2001
From: Matthieu Darcy <68646255+MatthieuDarcy@users.noreply.github.com>
Date: Tue, 1 Sep 2026 10:36:50 -0400
Subject: [PATCH 8/8] Update test_discrete_control.py

---
 tests/test_discrete_control.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/test_discrete_control.py b/tests/test_discrete_control.py
index 478fcea7..cd238d88 100644
--- a/tests/test_discrete_control.py
+++ b/tests/test_discrete_control.py
@@ -1196,4 +1196,3 @@ def test_mppi_n_simulations_draws_independent_rollouts_per_candidate():
     assert result.controls is not None
     assert result.states.shape[:3] == (n_samples, n_simulations, horizon)
     assert result.controls.shape[:3] == (n_samples, n_simulations, horizon)
-