Latest / Embodied AI 101 / SKooP: Symmetric Koopman Predictions for Legged Robot Reinforcement Learning
Transcript
- SKooP: Symmetric Koopman Predictions for Legged Robot Reinforcement Learning. In legged locomotion, pure model-free RL often struggles with sample efficiency and brittleness. Powerful simulators allow data-hungry methods to work, but convergence can still be slow, and policies may not generalize to new tasks or mirrored situations. On the other hand, classical model-based control can be very fast and reliable but requires hand-crafted models and tuning. A recent trend is to inject physics priors into RL, hoping to combine the best of both worlds: use data-driven learning where needed, but leverage structure in the problem to speed up learning. Two classes of priors are particularly relevant for legged robots: the morphological symmetries of the robot and the linearization of dynamics via Koopman theory. The new SKooP approach (Symmetric Koopman Predictions) marries these ideas in an actor-critic RL framework, yielding faster training and better generalization for quadruped locomotion tasks. In SKooP, an autoencoder learns a Koopman embedding of the robot’s nonlinear dynamics online during policy training, and the learned model is constrained by the robot’s left-right symmetry. The Koopman model’s predictions (future latent states) are fed as privileged information to the value critic, giving it an informative “peek” into the future. Meanwhile, the actor and critic networks are designed to respect left-right body symmetries. As a result, SKooP significantly accelerates policy learning and produces more symmetric, transferable behaviors than vanilla RL. This article unpacks SKooP in detail. We first review the key ideas of symmetry and Koopman operators in dynamics, and how past work has used them. Then we explain SKooP’s architecture and training procedure, emphasizing how symmetries and Koopman predictions are integrated into PPO-based RL. Finally, we go through the experimental validation: challenging bipedal-on-quad tasks, ablations, and insights from the learned Koopman models. The results show that SKooP consistently cuts convergence time and achieves higher ultimate rewards, while enabling policies to succeed on unseen symmetric tasks (e.g. mirrored door-opening). In short, SKooP demonstrates how physics-informed priors can pay off in complex robotic learning. Exploiting Physical Priors in RL. Reinforcement learning shines at tackling complex control problems without explicit modeling, but it can be painfully sample-inefficient. Every trial on a real robot might be costly or dangerous, so improving efficiency is crucial. Classic control theory, by contrast, often begins with a simplified or full dynamical model of the robot. A simple example is the inverted pendulum model of walking [36], or centroidal dynamics models [37,38] that capture overall momentum. These models make planning and control tractable but leave out details of the full robot’s multi-body dynamics. A middle ground is model-based RL, where a surrogate model is learned or used to aid learning. SKooP fits this paradigm: it does not assume a known model, but it concurrently learns a linearized model of the system via the Koopman operator concept. Before diving into SKooP’s method, it helps to understand the two main priors it injects:. Morphological Symmetry: Many legged robots (especially quadrupeds) are symmetric about the sagittal plane (left-right symmetry). Intuitively, what the robot can do looking to its left, it can do mirrored to its right. This means that whenever the robot traverses a sequence of states or generates actions on one side, there is a corresponding “mirror” version of the trajectory on the other side. In principle, a learning algorithm that knows this symmetry need only learn one side and can copy its knowledge to the other. A policy can be equivariant to the symmetry: if the state is reflected, the action should be reflected in the same way. Conversely, the value function should be invariant: a mirrored state yields the same value. Enforcing such symmetries in network architecture or training encourages data efficiency (the robot effectively learns two tasks at once) and ensures the learned behavior is balanced. Recent work has shown this can dramatically improve learning for legged robots [23] and humanoids, producing smoother gaits and enabling zero-shot transfer to real hardware. Koopman Linearization: The Koopman operator is a mathematical insight that any nonlinear dynamical system can be represented as a linear evolution in a higher-dimensional function space [36]. Concretely, if $x_{t+1}=F(x_t,u_t)$ are the dynamics, there exist (in principle infinitely many) observable functions $\psi_i(x)$ such that the lifted state $z_t = \psi(x_t)$ evolves linearly: $z_{t+1}=A z_t + B u_t$. In practice, we approximate this by learning a finite-dimensional encoder (and decoder) that map states into a latent space, along with matrices $A,B$ that best fit the dynamics. Prior work has used Koopman models for control (e.g., linear MPC on the latent model), and a few have plugged them into RL to speed up learning. For instance, the “Kippo” method [58] learned a Koopman autoencoder alongside a policy, feeding the policy the latent state instead of the raw state. Others have used Koopman models to shape value functions or tuning parameters. However, most of these were on low-dimensional benchmarks (cartpole, pendulum, etc.). SKooP is distinctive in applying Koopman embedding within a high-dimensional robotic RL setting and concurrently training it with the policy. Combining these two priors – symmetry and Koopman linearization – is novel in the context of robotic control. In fact, the Koopman viewpoint even aids symmetry: a global linear model can make invariances more explicit. The SKooP authors note a related offline RL work [22] that used Koopman linearization to improve symmetry in Q-learning, and a data-driven Koopman study [42] that embedded known symmetries in a Koopman autoencoder. But no prior has plugged Koopman predictions directly into policy learning for a real robot task. In SKooP, these ideas come together as follows: an equivariant autoencoder is learned that linearizes the dynamics; the actor and critic networks themselves enforce equivariance/invariance; and the predicted next latent-state (using the learned Koopman model) is given as extra input to the critic. This gives the critic a compact glimpse of the near future, which smooths out learning. The practical impact, as reported by D’Elia et al., is substantial: on various challenging bipedal motions for a quadruped, SKooP “consistently reduces convergence time and increases the learned reward” versus standard PPO, and yields more symmetric gaits. Moreover, SKooP-trained policies more robustly handle the mirrored versions of tasks never seen during training (for instance, a door-opening task trained on a right-opening door transfers to a left-opening door). Detailed ablations in the paper tease apart the benefits of symmetry constraints versus the latent predictions. Let us now unpack the SKooP method in detail. Enforcing Morphological Equivariance. Most legged robots have a left-right mirror symmetry. Formally, this symmetry group is $\mathbb{C}_2$, consisting of the identity transform $e$ and a reflection $g_s$ across the sagittal plane. If the robot’s state is given by joint angles and velocities $(q,\dot{q})$, then applying $g_s$ flips left and right joints (and mass distribution) but yields another valid configuration ${g_s \triangleright (q,\dot{q})}$. We say an action or control input $u$ is transformed similarly. In a symmetric robot, the reward or success criterion should be invariant under this flip (opening a door on the left or right should be equally good), but the policy should equivariantly respond (if the state is mirrored, the resulting torques should be mirrored too). To exploit this, SKooP constrains its neural networks to respect these symmetries. Concretely, the actor network is built as an equivariant function: if we reflect the input state $x$ to $g_s \triangleright x$, then the action output is likewise reflected: $\pi_\theta(g_s \triangleright x) = g_s \triangleright \pi_\theta(x)$. In practice this is done by designing the MLP (multi-layer perceptron) layers to share weights or use basis functions that commute with the group actions (the paper uses an “Equivariant MLP” construction drawn from recent tensor-based network designs). The critic network (value function) is constrained to be invariant: its value output does not change if the state is flipped. Intuitively, the critic only needs to learn how good a state is, which shouldn’t depend on left vs right. This type of equivariant/invariant actor-critic has been shown to improve learning. For example, D’Elia et al. cite and build on a 2024 paper [23] where a purely equivariant policy (and invariant critic) reached better sample efficiency and more natural gaits on benchmark locomotion tasks. Indeed, [23] reports that a strictly equivariant policy “consistently outperforms other methods in sample efficiency and task performance”. SKooP adopts the same idea but extends it further: the Koopman autoencoder itself is made equivariant too. That is, the encoder function $f_\phi(x)$ and decoder $f_\phi^{-1}(z)$ are each designed so that reflecting $x$ causes a corresponding reflection in the latent output $z$. As a result, all parts of SKooP’s state representation—the actual robot state and the latent Koopman embedding—live in vector spaces with matching symmetry representations. Why is this useful? Enforcing symmetry reduces redundant degrees of freedom. For instance, if the robot’s left and right legs are symmetric, the latent representation can be decomposed into “left-right symmetric” and “left-right antisymmetric” modes. Mathematically, the latent space splits into isotypic subspaces corresponding to irreducible representations of $\mathbb{C}_2$. The learned Koopman matrices $A,B$ then become block-diagonal, one block per subspace. This block structure means the autoencoder is effectively learning separate linear dynamics for symmetric and antisymmetric components of motion. Importantly, symmetry constraints are rigorously respected by the network (not just via data augmentation) because of the architecture. In practice, this means if the robot did a certain maneuver on the right side, SKooP automatically knows how to do the mirrored maneuver on the left, without extra training data. In summary, SKooP applies symmetry priors at multiple levels: in the policy/value network design, and in the Koopman embedding. The authors note that without these constraints, a policy might overfit to one side (say, always favor stepping with the left leg) and fail to generalize when the task flips. With equivariance, SKooP eliminates such biases by design. Learning a Koopman Dynamics Model. While symmetry constrains who we are learning, the Koopman theory constrains what we learn about the dynamics. SKooP uses an autoencoder-based approach to learn a linear latent model of the robot’s controlled dynamics. In effect, it learns functions $f_\phi(x)$ (encoder) and $f_\phi^{-1}(z)$ (decoder) together with matrices $A,B$ so that $$z_{t+1} \approx A z_t + B u_t,\quad z_t = f_\phi(x_t).$$ Because $f_\phi$ and $f_\phi^{-1}$ are neural nets (deep AutoEncoder style), SKooP can in principle discover a powerful nonlinear embedding that makes the dynamics almost linear. This is conceptually similar to other recent "deep Koopman" methods [57]–[60], but SKooP does it live, during RL training. The paper extends an existing architecture called the Equivariant Dynamics Auto-Encoder (eDAE) into what they term an Equivariant Controlled Dynamics Auto-Encoder (ecDAE). The eDAE idea (from [42]) was to train an autoencoder whose latent dynamics matrix $A$ is forced to respect symmetry. The SKooP ecDAE similarly encodes and decodes equivariantly, and it explicitly takes the control input into account. In particular, for a lookahead horizon of $H$ timesteps, the ecDAE enforces that $$z_{k+H} = A^H f_\phi(x_k) + \sum_{i=0}^{H-1} A^{H-1-i} B,u_{k+i},$$ meaning we can predict the latent state $H$ steps ahead linearly from the current encoded state and a sequence of controls. In practice SKooP uses a rather short horizon (they report $H=5$), but this multi-step prediction is a known trick to stabilize Koopman training. How is this trained? SKooP minimizes several losses as training proceeds in parallel with policy learning:. State reconstruction loss ($\mathcal{L}_{sr}$): ensure $f_\phi^{-1}(f_\phi(x_k))$ reconstructs the original state $x_k$ faithfully. Latent prediction loss ($\mathcal{L}_{lp}$): make sure one-step predictions in latent space match the encoding of the next state. State prediction loss ($\mathcal{L}_{sp}$): measure how well the decoded predicted state matches the actual future state (over $H$ steps). These are “standard” autoencoder and dynamics modeling losses in flavor. Crucially, all of these networks ($f_\phi$ and its inverse) are equivariant as explained earlier, so the Koopan model itself embeds the left-right symmetry. The SKooP paper notes that enforcing equivariance in the basis functions yields a symmetric function space for $z=f_\phi(x)$, so that indeed $A,B$ break into symmetric blocks. In particular, an interesting phenomenon emerges: for some tasks, the ecDAE learns an eigen-direction $|\lambda|\approx 1$ (exactly marginally stable) corresponding to the symmetric, invariant part of the motion. We’ll discuss that more in the analysis below. Importantly, no separate offline pre-training of the Koopman model is done. SKooP trains $f_\phi$, $A$, $B$ at the same time as the RL agent is collecting data. At the very start of training, SKooP collects some random-rollout data to seed a replay buffer for the autoencoder. Then, every time the policy takes a step, SKooP also takes a gradient step on the ecDAE losses using a mini-batch from this buffer. The buffer is managed with Prioritized Experience Replay (PER) [51], meaning transitions that produce higher model loss are sampled more frequently. This ensures the autoencoder focuses on dynamics that are currently hard to model, keeping its predictions sharp on the regions of state space the policy actually visits. Thus, SKooP has an online learning Koopman model, which evolves as the policy improves. The advantage is that the Koopman network only sees realistic states (no need for superficial pre-training on random data) and it adapts if the robot explores new behaviors. The downside is some extra computation, but the authors report that SKooP’s iterations (PPO update plus ecDAE update) take only ~34% longer than vanilla PPO, which is acceptable given the speed-ups in learning. Privileged Latent-State for the Critic. A key twist in SKooP is how the Koopman model is used to help learning. Instead of feeding the encoded latent $z_t = f_\phi(x_t)$ to the actor (as in Kippo [58]), SKooP takes an asymmetric actor-critic viewpoint: the actor still only sees the raw state $x_t$, but the critic receives a “privileged” future observation – namely a predicted next-latent-state $z_{t+1}$. Concretely, at each timestep $t$ SKooP computes $$ z_{t+1}^{\rm pred} = A,f_\phi(x_t) + B,u_t, $$ using the current learned Koopman model parameters. This single-step prediction of the latent state is then concatenated (or paired) with the actual state $x_t$ as input to the value function network. Since the critic is already invariant/equivariant as needed, it effectively has a richer input – it sees not just where the system is, but an internal estimate of where it will be after the next step. Crucially, this does not burden the actor, so at deployment time the policy still only needs $x_t$ to act. Why do this? Feeding predicted future state to the critic is a way of injecting a predictive prior on the value estimation. The value function is trying to estimate expected cumulative reward, and it usually must rely on just the current state. By giving it $z_{t+1}^{\rm pred}$, SKooP allows the critic to better assess the trajectory. Intuitively, this smoothing can reduce variance: the critic doesn’t have to first learn the dynamics internally, it’s nudged with a hint from the Koopman model. In robotics terms, it’s akin to giving an MPC controller hints about the horizon, except here it's a learned linear hint. This idea resonates with other “asymmetric” RL tricks: for example, some robotic RL works give the critic extra sensors or oracle information that the actor doesn’t see, to accelerate learning [61]. Here the extra information comes from a learned dynamics model. D’Elia et al. indeed point out that this asymmetric design “informs training without increasing overhead at deployment”. To summarize SKooP’s flow at each interaction step:. Given state $x_t$, actor $\pi_\theta$ (equivariant) produces action $u_t$. The environment (simulator) returns $x_{t+1}$ (and reward). Meanwhile, the Koopman autoencoder updates: encode $x_t$ and $x_{t+1}$ to $z_t = f_\phi(x_t)$, $z_{t+1}=f_\phi(x_{t+1})$; compute prediction $z_{t+1}^{\rm pred} = A z_t + B u_t$. The critic network receives $(x_t, z_{t+1}^{\rm pred})$ and assesses value; the actor receives $x_t$ as usual. We perform a PPO update using these values, and also take a gradient step to reduce the autoencoder losses ($\mathcal{L}{sr}$, $\mathcal{L}{lp}$, $\mathcal{L}_{sp}$) via PER-sampled replay. The net effect is that the critic’s learning is guided by the Koopman model’s prediction. As the paper reports, this addition improves both convergence speed and final performance. In ablations they show that even without symmetry constraints, adding the latent state ($z_t$ instead of $z_{t+1}$) gave some benefit, but the full gain was achieved only when both symmetry and the prediction were in place. Experimental Setup: Bipedal Gaits on a Quadruped. To test SKooP, the authors consider multiple challenging tasks where a quadruped robot must rear up and walk on its hind legs. They use the Xiami CyberDog 2 platform in simulation via Nvidia’s Isaac Gym (for large-scale parallelism). Three specific tasks are evaluated:. Stand and Dance: The robot stands still and moves its legs in a dancing motion, balancing on its hind legs. Walk Up Slope: The robot must rear up and climb a slope with its hind legs. Push Door: The robot rears up, opens a door by pushing it, and walks through. These tasks are “bipedal” in that only the rear two legs are used, but the robot’s full body and four legs are still present. The observation space is high-dimensional (43–47 state variables, including body pose, joint angles, velocities, etc.), and the action space is the torques of 12 motors (the same baseline actuated joints as normal quadruped gaits). Reward functions include terms for standing upright, reaching velocity commands, accomplishing the task (e.g. opening a door past a threshold), stability, etc., as described in detail in the appendix of the paper. SKooP (with PPO) is trained on these tasks with 8192 parallel simulation environments, for up to 30,000 iterations (with 5 random seeds per task). For reference, each iteration collects rollouts and then does a PPO gradient step. They also trained baseline methods for comparison:. PPO: Standard Proximal Policy Optimization with no symmetry or Koopman priors. PPO-EqIC: An ablation that is PPO with an equivariant (symmetric) actor and invariant critic, but without any Koopman components. This is essentially the method of [23] reimplemented (equiv. actor, inv. critic, equiv. encoder/decoder not used). SKooP-NoPred: Full SKooP with symmetries everywhere but the critic does not get the latent prediction; it only sees $z_t$ (the current encoder latent). SKooP-NoSym-NoPred: No symmetry constraints, and the critic just sees $z_t$ (so this is essentially Kippo-like, a Koopman autoencoder but with neither sym. nor future prediction). SKooP-NoSym: No symmetry, but the critic does get $z_{t+1}^{\rm pred}$. (So this tests if just the predicted information helps, absent equivariance.). All setups use the same PPO framework otherwise. To implement symmetry easily, SKooP uses open-source equivariant network tools (ESCNN library [45]) and a library for symmetries of robotics [16]. The latent space size is set to triple the state size (based on a dimensionality ratio of 3:1), and the PER buffer for the autoencoder holds 10,000 transitions. During training, SKooP logs standard metrics like episode return, training value loss, plus some task-specific success and gait metrics. In particular, for the door task they define Success Rate (SR) as the percentage of episodes in which the robot opened the door sufficiently and walked through. They also define a Symmetry Index (SI) to quantify how differently the policy behaves on the original task versus its mirror: $$ \mathrm{SI} = \frac{2|X_R - X_L|}{X_R + X_L} \times 100%, $$ where $X_R$ is success rate on the “right-opening” door (trained side) and $X_L$ is success on the “left-opening” (mirrored) door. An SI of 0% means perfect symmetry (equal success on left and right), while 100% means only one side ever succeeds. With the setup and metrics defined, what do the experiments show?. Results: Faster Learning and Symmetric Gaits. Across all three tasks, SKooP outperformed the baselines in learning speed and eventual return. Figure 3 in the paper (training curves) shows that applying symmetry (PPO-EqIC) alone already gives a steeper early convergence than plain PPO. Both SKooP and the variant SKooP-NoPred (which uses symmetries but no latent prediction) also converge faster than PPO, especially in the first phase. In fact, incorporating the latent state (even without prediction) often on its own improved convergence rate, and adding symmetry improved it further. Using the prediction $z_{t+1}$ instead of just $z_t$ caused a tiny delay in early learning (because the model is initially inaccurate), but by training end the full SKooP always reached the highest reward. The margin of improvement was largest on the hardest task (Push Door). There, PPO-EqIC learned more quickly than vanilla PPO but stalled at a lower final reward. The SKooP variants achieved higher final returns. The unconstrained SKooP-NoSym and SKooP-NoSym-NoPred learned quickly too (and even surpassed SKooP early on), but they paid a price: their policies became asymmetric. That is, they mastered the training task (the door opening on the right) but utterly failed on the left side version. Table I in the paper quantifies this. On the right-opening door, PPO got a success rate of about 70%, but 0% on the left (it never learned to open the mirrored door). SKooP-NoSym variants also had ~83% right but only ~0% left, yielding an SI near 200% (maximum). In contrast, PPO-EqIC (symmetric policy) got only ~40% on either side (because it was more conservative) but had virtually 0 SI (it generalized). The biggest win was SKooP (full): it achieved about 82.8% success on the right and 77.7% on the left. Expressed as an SI, SKooP was around 8.5%—indicating almost perfect symmetry. Crucially, SKooP not only learned both sides but did so with higher success than PPO-EqIC. In other words, adding Koopman predictions let SKooP recover the higher return of the unconstrained policies while preserving symmetry. These gains were not just luck. The text discusses how SKooP-NoPred (symmetry but no prediction) did much better than PPO-EqIC on both left and right, and SKooP (with prediction) did even better. In the authors’ words, using the Koopman’s predicted latent state “enables significantly higher success rates on both the right and left. with respect to PPO-EqIC,” and SKooP’s additional prediction gave it the edge over SKooP-NoPred. They also note that SKooP’s learning curves have lower variance across random seeds, suggesting steadier training. What about the other tasks? The “stand dance” and “walk slope” tasks showed similar trends, though improvements were more modest. All methods eventually reached good performance on stand dance (an easier task), so SKooP’s advantage was mainly in convergence speed and gait quality. On “walk slope”, the benefits of symmetry and latent input also appeared, but again push-door was the most striking differential. In terms of motion quality, SKooP policies learned smoother and more periodic hind-leg motions. The authors measured gait phase consistency and find SKooP roughly matched or slightly beat the equivariant baseline (PPO-EqIC) on phase metrics, whereas unconstrained PPO had larger phase error. This indicates SKooP kept the legs well-coordinated. (Full numbers are in Table II of the paper: e.g. SKooP’s mean phase error was 0.17 radians vs 0.216 for PPO.). Another important test was robustness and transfer. The team tried adding random perturbations to testing conditions (small base angle offsets, varied friction, etc.) and measured success rates. SKooP’s policies remained successful at high rates, largely maintaining symmetry (low SI) even under these out-of-distribution starts. Perhaps most impressively, they ran a sim-to-sim transfer: a policy trained in Isaac Gym was tested in MuJoCo, which has more accurate physics. The SKooP policy survived all trials and showed similar performance in commanding linear motion, with only some degradation in yaw tracking. This suggests the learned policy (and its symmetric structure) generalizes well beyond the original training simulator. In summary, the experiments paint a consistent picture: SKooP learns faster and better. Convergence curves show measurable speed-up (see Fig. 3 in the paper), and final task success (mean reward) is higher for SKooP than baselines. Most importantly, SKooP gives balanced performance on both original and mirrored tasks – a form of “built-in” generalization. The improvements are not trivial: on push-door, SKooP’s success is essentially double that of plain PPO, and the symmetry index collapses from ~200% (complete failure on one side) to ~8%. Dissecting the Koopman Model. Beyond policy performance, SKooP yields an interpretable latent model of the robot’s dynamics. The authors analyze the learned Koopman matrices $A,B$ for insight. One pattern stands out: when the symmetry priors are enforced, the largest magnitude eigenvalue $|\lambda_{\max}(A)|$ tends to be very close to 1, whereas without symmetry it is smaller (more contractive). In fact, in two of the three tasks SKooP’s ecDAE finds an eigenvalue practically equal to 1.0. This “unit eigenmode” corresponds to an invariant motion: in simple terms, a constant-shape component of the state. For instance, if the robot’s symmetric stance has a certain center-of-mass above the feet, that condition might form a constant mode in the linear model. Without symmetry constraints, the Koopman autoencoder typically does not discover this neutral mode. Accompanying this, the controllability analysis shows the equivariant Koopman model has fewer independent control directions. The condition number of the controllability matrix $\mathcal{C}=[B,\ AB,\dots,A^{n-1}B]$ is higher and its rank lower for the ecDAE than for an unconstrained DAE. This means the symmetric model recognizes that, say, left and right leg motions are not fully independent when pushing; they share common controls. Conceptually, SKooP “finds” that controlling the sum-of-left-plus-right (the symmetric combination) is more crucial than the difference – hence one invariant mode. Table IV in the paper compares errors of a unconstrained Koopman (cDAE) versus the equivariant one (ecDAE) on the push-door task. The ecDAE has lower prediction error on both the training trajectory and the unseen mirrored trajectory. Notably, on the left/mirrored door task the ecDAE’s 5-step state prediction MSE (around 1.78) is much closer to its right-side error (1.78 vs 1.78!), whereas the cDAE’s error on the left is 3.15 (about 50% worse than its 2.14 on the right). In the text, the authors remark that without symmetry, the model’s state prediction on the mirrored version of the task was roughly 50% worse, whereas with symmetry the ecDAE was almost identical on both sides. They attribute this to the invariant mode: the symmetric autoencoder effectively recovers an internal representation that doesn’t care left-vs-right, so it predicts equally well on both. They validate this by ablating the invariant component. If they “disable” the λ=1 mode in the ecDAE (i.e. force all modes to decay), the state prediction error shoots up dramatically for both directions. Likewise, if they keep only the invariant mode and zero out others, performance is poor. This confirms the λ≈1 mode is not a fluke: it encodes a genuine symmetry. Overall, the analysis shows that the symmetry-informed Koopman embedding is more compact and consistent, representing essentially just the independent dynamical modes that respect the robot’s bilateral symmetry. From a practical standpoint, these model diagnostics justify the intuitive results: a Koopman model that mirrors the true symmetry leads to better multi-step predictions. This in turn likely helps the critic’s learning stability and the policy’s smoothness. The fact that SKooP outperforms even the best symmetric-only policy (PPO-EqIC) suggests the latent predictions indeed give an extra learning signal beyond architecture bias. Conclusion. SKooP is an elegant demonstration of blending two rich ideas – symmetry and Koopman linearization – to tackle a real robotic RL problem. By simultaneously learning an equivariant linear model of the dynamics and using it to guide the value function, SKooP achieves faster learning and more general policies. The experimental results on quadruped bipedal tasks are compelling: policies train in fewer samples, get higher final returns, and crucially can handle mirror-image tasks that were not part of training. In the authors’ words, SKooP “accelerates convergence and improves reward performance” while enabling generalization beyond training scenarios. What makes SKooP particularly appealing is its modularity. The method is essentially an add-on to an actor-critic algorithm: you can take any PPO or similar, make it equivariant, and slip in the Koopman autoencoder training and the predicted latent to the critic. Indeed, the authors stress that SKooP is compatible with any actor-critic. The use of prioritized replay for the dynamics model, equivariant network libraries (ESCNN), and even the parallel Isaac Gym training imply that an open-source implementation could be spun up by an interested team – and the project page indicates code and videos will be available. One can envision follow-ups exploring extensions. For example, could the Koopman model be made more sophisticated (multi-scale, deeper embeddings) or used for planning (e.g. latent-space MPC)? The authors suggest future work in that direction. Also, transferring these policies to real hardware would be a litmus test — the sim-to-sim robustness is promising, but real-world noise is another challenge. Possibly the learned latent model could help with real-world adaptation too, by revealing control directions that generalize across conditions. In sum, SKooP illustrates that injecting structured physics knowledge into RL is not just theoretical nicety – it yields concrete gains. Legged locomotion, with its high-dimensional, nonlinear dynamics and inherent symmetries, is an ideal proving ground. SKooP’s success on the CyberDog tasks suggests that other robots and tasks with symmetry (humanoids, bipedal with arm symmetry, etc.) could benefit similarly. For practitioners of embodied AI, this reinforces the lesson that understanding the problem’s geometry and dynamics can dramatically amplify the effectiveness of learning algorithms. References: D’Elia et al., “SKooP: Symmetric Koopman Predictions for Faster and More Generalizable Legged Robot Locomotion with Reinforcement Learning”, arXiv:2607.11624, 2026. (See also Su et al., Leveraging Symmetry in RL-based Legged Locomotion Control, IROS 2024.).