code: def rts_smoother(Xs, Ps, Fs, Qs):
      """
      Runs the Rauch-Tung-Striebel Kalman smoother on a set of
      means and covariances computed by a Kalman filter. The usual input
      would come from the output of `KalmanFilter.batch_filter()`.
  
      Parameters
      ----------
  
      Xs : numpy.array
         array of the means (state variable x) of the output of a Kalman
         filter.
  
      Ps : numpy.array
          array of the covariances of the output of a kalman filter.
  
      Fs : list-like collection of numpy.array
          State transition matrix of the Kalman filter at each time step.
  
      Qs : list-like collection of numpy.array, optional
          Process noise of the Kalman filter at each time step.
  
      Returns
      -------
  
      x : numpy.ndarray
         smoothed means
  
      P : numpy.ndarray
         smoothed state covariances
  
      K : numpy.ndarray
          smoother gain at each step
  
      pP : numpy.ndarray
         predicted state covariances
  
      Examples
      --------
  
      .. code-block:: Python
  
          zs = [t + random.randn()*4 for t in range (40)]
  
          (mu, cov, _, _) = kalman.batch_filter(zs)
          (x, P, K, pP) = rts_smoother(mu, cov, kf.F, kf.Q)
      """
  
      if len(Xs) != len(Ps):
          raise ValueError("length of Xs and Ps must be the same")
  
      n = Xs.shape[0]
      dim_x = Xs.shape[1]
  
      # smoother gain
      K = zeros((n, dim_x, dim_x))
      x, P, pP = Xs.copy(), Ps.copy(), Ps.copy()
  
      for k in range(n - 2, -1, -1):
          pP[k] = dot(dot(Fs[k], P[k]), Fs[k].T) + Qs[k]
  
          # pylint: disable=bad-whitespace
          K[k] = dot(dot(P[k], Fs[k].T), linalg.inv(pP[k]))
          x[k] += dot(K[k], x[k + 1] - dot(Fs[k], x[k]))
          P[k] += dot(dot(K[k], P[k + 1] - pP[k]), K[k].T)
  
      return (x, P, K, pP)
  
imports: from __future__ import absolute_import, division
  from copy import deepcopy
  from math import log, exp, sqrt
  import sys
  import numpy
  from numpy import dot, zeros, eye, isscalar, shape
  import numpy.linalg
  from filterpy.stats import logpdf
  from filterpy.common import pretty_str, reshape_z
label_desc: Use image node_id 6 for calling a global function with example usage: rts_smoother(Xs, Ps, Fs, Qs) and returns: x,  P,  K,  pP