diff --git a/README.md b/README.md
index 1178e9385..66e7bc0c4 100644
--- a/README.md
+++ b/README.md
@@ -58,10 +58,10 @@ k.x(60.);
 k.p(225.);
 k.r(25.);
 
-k.observe(48.54);
+k.update(48.54);
 ```
 
-### Multi-Dimensional
+## Multi-Dimensional
 
 Two states, one control, using Eigen3 support.
 
@@ -94,9 +94,9 @@ k.h(1, 0);
 k.r(400);
 
 k.predict(delta_time, gravitational_acceleration);
-k.observe(-32.40 );
+k.update(-32.40 );
 k.predict(delta_time, 39.72);
-k.observe(-11.1);
+k.update(-11.1);
 ```
 
 # Library
@@ -105,19 +105,19 @@ k.observe(-11.1);
 - [Continuous Integration & Deployment Actions](#continuous-integration--deployment-actions)
 - [Examples](#examples)
   - [One-Dimensional](#one-dimensional)
-    - [Multi-Dimensional](#multi-dimensional)
+  - [Multi-Dimensional](#multi-dimensional)
 - [Library](#library)
-- [Motivation](#motivation)
+  - [Motivation](#motivation)
+  - [Class fcarouge::kalman](#class-fcarougekalman)
+    - [Template Parameters](#template-parameters)
+    - [Member Types](#member-types)
+    - [Member Functions](#member-functions)
+      - [Characteristics](#characteristics)
+      - [Modifiers](#modifiers)
 - [Resources](#resources)
-- [Class fcarouge::kalman](#class-fcarougekalman)
-  - [Template Parameters](#template-parameters)
-  - [Member Types](#member-types)
-  - [Member Functions](#member-functions)
-    - [Characteristics](#characteristics)
-    - [Modifiers](#modifiers)
 - [License](#license)
 
-# Motivation
+## Motivation
 
 Kalman filters can be difficult to learn, use, and implement. Users often need fair algebra, domain, and software knowledge. Inadequacy leads to incorrectness, underperformance, and a big ball of mud.
 
@@ -126,14 +126,7 @@ This package explores what could be a Kalman filter implementation a la standard
 - Separation of the algebra implementation.
 - Generalization of the support.
 
-# Resources
-
-Awesome resources to learn about Kalman filters:
-
-- [KalmanFilter.NET](https://www.kalmanfilter.net) by Alex Becker.
-- [Kalman and Bayesian Filters in Python](https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python) by Roger Labbe.
-
-# Class fcarouge::kalman
+## Class fcarouge::kalman
 
 Defined in header [fcarouge/kalman.hpp](include/fcarouge/kalman.hpp)
 
@@ -147,9 +140,9 @@ template <typename State, typename Output = State, typename Input = State,
 class kalman
 ```
 
-## Template Parameters
+### Template Parameters
 
-## Member Types
+### Member Types
 
 | Member Type | Definition |
 | --- | --- |
@@ -163,7 +156,7 @@ class kalman
 | `output_model` | Type of the observation transition matrix H, also known as C. |
 | `input_control` | Type of the control transition matrix G, also known as B. |
 
-## Member Functions
+### Member Functions
 
 | Member Function | Definition |
 | --- | --- |
@@ -171,7 +164,7 @@ class kalman
 | `(destructor)` | Destructs the filter. |
 | `operator=` | Assigns values to the filter. |
 
-### Characteristics
+#### Characteristics
 
 | Modifier | Definition |
 | --- | --- |
@@ -185,13 +178,20 @@ class kalman
 | `h` | Manages the observation transition matrix. |
 | `g` | Manages the control transition matrix. |
 
-### Modifiers
+#### Modifiers
 
 | Modifier | Definition |
 | --- | --- |
-| `observe` | Updates the estimates with the outcome of a measurement. |
+| `update` | Updates the estimates with the outcome of a measurement. |
 | `predict` | Produces estimates of the state variables and uncertainties. |
 
+# Resources
+
+Awesome resources to learn about Kalman filters:
+
+- [KalmanFilter.NET](https://www.kalmanfilter.net) by Alex Becker.
+- [Kalman and Bayesian Filters in Python](https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python) by Roger Labbe.
+
 # License
 
 <img align="right" src="http://opensource.org/trademarks/opensource/OSI-Approved-License-100x137.png">
diff --git a/include/fcarouge/internal/kalman.hpp b/include/fcarouge/internal/kalman.hpp
index c4060d087..0d00fccb0 100644
--- a/include/fcarouge/internal/kalman.hpp
+++ b/include/fcarouge/internal/kalman.hpp
@@ -182,12 +182,12 @@ struct kalman {
   //! @name Public Member Functions
   //! @{
 
-  inline constexpr void observe(const auto &...output_z)
+  inline constexpr void update(const auto &...output_z)
   {
     h = transition_observation_h();
     r = noise_observation_r();
     const auto z{ output{ output_z... } };
-    internal::observe<Transpose, Symmetrize, Divide, Identity>(x, p, h, r, z);
+    internal::update<Transpose, Symmetrize, Divide, Identity>(x, p, h, r, z);
   }
 
   inline constexpr void predict(const PredictionArguments &...arguments,
diff --git a/include/fcarouge/internal/kalman_equation.hpp b/include/fcarouge/internal/kalman_equation.hpp
index 481cf758f..039e0f4dc 100644
--- a/include/fcarouge/internal/kalman_equation.hpp
+++ b/include/fcarouge/internal/kalman_equation.hpp
@@ -134,8 +134,8 @@ template <template <typename> typename Transpose,
           template <typename> typename Symmetrize,
           template <typename, typename> typename Divide,
           template <typename> typename Identity>
-inline constexpr void observe(auto &x, auto &p, const auto &h, const auto &r,
-                              const auto &z)
+inline constexpr void update(auto &x, auto &p, const auto &h, const auto &r,
+                             const auto &z)
 {
   const auto k{ weight_gain<Transpose, Divide>(p, h, r) };
 
diff --git a/include/fcarouge/kalman.hpp b/include/fcarouge/kalman.hpp
index 1056c2d88..c6cf144af 100644
--- a/include/fcarouge/kalman.hpp
+++ b/include/fcarouge/kalman.hpp
@@ -50,6 +50,8 @@ namespace fcarouge
 {
 //! @brief Kalman filter.
 //!
+//! @details Bayesian filter that uses Gaussians.
+//!
 //! @tparam State The type template parameter of the state vector x.
 //! @tparam Output The type template parameter of the measurement vector z.
 //! @tparam Input The type template parameter of the control u.
@@ -261,6 +263,8 @@ class kalman
 
   //! @brief Returns the observation, measurement noise covariance matrix R.
   //!
+  //! @details The variance there is in each measurement.
+  //!
   //! @return The observation, measurement noise covariance matrix R.
   //!
   //! @complexity Constant.
@@ -354,12 +358,17 @@ class kalman
 
   //! @brief Updates the estimates with the outcome of a measurement.
   //!
+  //! @details Implements the Bayes' theorem?
+  //! Combine one measurement and the prior estimate.
+  //!
   //! @tparam output_z Observation parameters. Types must be compatible with the
   //! `output` type.
-  inline constexpr void observe(const auto &...output_z);
+  inline constexpr void update(const auto &...output_z);
 
   //! @brief Produces estimates of the state variables and uncertainties.
   //!
+  //! @details Implements the total probability theorem?
+  //!
   //! @param arguments Optional prediction parameters passed through for
   //! computations of prediction matrices.
   //! @param input_u Optional control parameters. Types must be compatible with
@@ -551,6 +560,21 @@ kalman<State, Output, Input, Transpose, Symmetrize, Divide, Identity,
   // +reset function
 }
 
+template <typename State, typename Output, typename Input,
+          template <typename> typename Transpose,
+          template <typename> typename Symmetrize,
+          template <typename, typename> typename Divide,
+          template <typename> typename Identity,
+          typename... PredictionArguments>
+[[nodiscard]] inline constexpr
+    typename kalman<State, Output, Input, Transpose, Symmetrize, Divide,
+                    Identity, PredictionArguments...>::input_control
+    kalman<State, Output, Input, Transpose, Symmetrize, Divide, Identity,
+           PredictionArguments...>::g() const
+{
+  return filter.g;
+}
+
 template <typename State, typename Output, typename Input,
           template <typename> typename Transpose,
           template <typename> typename Symmetrize,
@@ -573,9 +597,9 @@ template <typename State, typename Output, typename Input,
           typename... PredictionArguments>
 inline constexpr void
 kalman<State, Output, Input, Transpose, Symmetrize, Divide, Identity,
-       PredictionArguments...>::observe(const auto &...output_z)
+       PredictionArguments...>::update(const auto &...output_z)
 {
-  filter.observe(output_z...);
+  filter.update(output_z...);
 }
 
 template <typename State, typename Output, typename Input,
diff --git a/sample/building_height.cpp b/sample/building_height.cpp
index 02c7ad8fd..f81577702 100644
--- a/sample/building_height.cpp
+++ b/sample/building_height.cpp
@@ -51,18 +51,18 @@ namespace
   // the measurement uncertainty is: r1 = 25.
   k.r(25.);
 
-  k.observe(48.54);
+  k.update(48.54);
 
   // And so on.
-  k.observe(47.11);
-  k.observe(55.01);
-  k.observe(55.15);
-  k.observe(49.89);
-  k.observe(40.85);
-  k.observe(46.72);
-  k.observe(50.05);
-  k.observe(51.27);
-  k.observe(49.95);
+  k.update(47.11);
+  k.update(55.01);
+  k.update(55.15);
+  k.update(49.89);
+  k.update(40.85);
+  k.update(46.72);
+  k.update(50.05);
+  k.update(51.27);
+  k.update(49.95);
 
   // After 10 measurements the filter estimates the height of the building
   // at 49.57m.
diff --git a/sample/dog_position.cpp b/sample/dog_position.cpp
new file mode 100644
index 000000000..159f3f2e9
--- /dev/null
+++ b/sample/dog_position.cpp
@@ -0,0 +1,96 @@
+#include "fcarouge/kalman.hpp"
+
+#include <cassert>
+
+namespace fcarouge::sample
+{
+namespace
+{
+//! @test Estimating the Position of a Dog
+//!
+//! @copyright This example is transcribed from Kalman and Bayesian Filters in
+//! Python copyright Roger Labbe
+//!
+//! @see
+//! https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python/blob/master/04-One-Dimensional-Kalman-Filters.ipynb
+//!
+//! @details Assume that in our latest hackathon someone created an RFID tracker
+//! that provides a reasonably accurate position of the dog. The sensor returns
+//! the distance of the dog from the left end of the hallway in meters. So, 23.4
+//! would mean the dog is 23.4 meters from the left end of the hallway. The
+//! sensor is not perfect. A reading of 23.4 could correspond to the dog being
+//! at 23.7, or 23.0. However, it is very unlikely to correspond to a position
+//! of 47.6. Testing during the hackathon confirmed this result - the sensor is
+//! 'reasonably' accurate, and while it had errors, the errors are small.
+//! Furthermore, the errors seemed to be evenly distributed on both sides of the
+//! true position; a position of 23 m would equally likely be measured as 22.9
+//! or 23.1. Perhaps we can model this with a Gaussian. We predict that the dog
+//! is moving. This prediction is not perfect. Sometimes our prediction will
+//! overshoot, sometimes it will undershoot. We are more likely to undershoot or
+//! overshoot by a little than a lot. Perhaps we can also model this with a
+//! Gaussian.
+//!
+//! @example dog_position.cpp
+[[maybe_unused]] auto building_height{ [] {
+  using kalman = kalman<double>;
+  kalman k;
+
+  // Initialization
+  // This is the dog's initial position expressed as a Gaussian. The position is
+  // 0 meters, and the variance to 400 m, which is a standard deviation of 20
+  // meters. You can think of this as saying "I believe with 99.7% accuracy the
+  // position is 0 plus or minus 60 meters". This is because with Gaussians
+  // ~99.7% of values fall within of the mean.
+  k.x(1.);
+  k.p(20 * 20.);
+
+  // Prediction
+  // Variance in the dog's movement. The process variance is how much error
+  // there is in the process model. Dogs rarely do what we expect, and things
+  // like hills or the whiff of a squirrel will change his progress.
+  k.q(1.);
+
+  // Measure and Update
+  // Variance in the sensor. The meaning of sensor variance should be clear - it
+  // is how much variance there is in each measurement.
+  k.r(2.);
+
+  // We are predicting that at each time step the dog moves forward one meter.
+  // This is the process model - the description of how we think the dog moves.
+  // How do I know the velocity? Magic? Consider it a prediction, or perhaps we
+  // have a secondary velocity sensor. Please accept this simplification for
+  // now.
+  k.g(1.);
+
+  k.predict(1.);
+  k.update(1.354);
+  k.predict(1.);
+  k.update(1.882);
+  k.predict(1.);
+  k.update(4.341);
+  k.predict(1.);
+  k.update(7.156);
+  k.predict(1.);
+  k.update(6.939);
+  k.predict(1.);
+  k.update(6.844);
+  k.predict(1.);
+  k.update(9.847);
+  k.predict(1.);
+  k.update(12.553);
+  k.predict(1.);
+  k.update(16.273);
+  k.predict(1.);
+  k.update(14.8);
+
+  assert(
+      15.053 - 0.001 < k.x() && k.x() < 15.053 + 0.001 &&
+      "Here we can see that the variance converges to 2.1623 in 9 steps. This "
+      "means that we have become very confident in our position estimate. It "
+      "is equal to meters. Contrast this to the sensor's meters.");
+
+  return 0;
+}() };
+
+} // namespace
+} // namespace fcarouge::sample
diff --git a/sample/liquid_temperature.cpp b/sample/liquid_temperature.cpp
index 5f685f0b0..25e7f7165 100644
--- a/sample/liquid_temperature.cpp
+++ b/sample/liquid_temperature.cpp
@@ -66,27 +66,27 @@ namespace
   // Celsius.
   k.r(0.1 * 0.1);
 
-  k.observe(49.95);
+  k.update(49.95);
 
   // And so on, every measurements period: Δt = 5s (constant).
   k.predict();
-  k.observe(49.967);
+  k.update(49.967);
   k.predict();
-  k.observe(50.1);
+  k.update(50.1);
   k.predict();
-  k.observe(50.106);
+  k.update(50.106);
   k.predict();
-  k.observe(49.992);
+  k.update(49.992);
   k.predict();
-  k.observe(49.819);
+  k.update(49.819);
   k.predict();
-  k.observe(49.933);
+  k.update(49.933);
   k.predict();
-  k.observe(50.007);
+  k.update(50.007);
   k.predict();
-  k.observe(50.023);
+  k.update(50.023);
   k.predict();
-  k.observe(49.99);
+  k.update(49.99);
 
   // The estimate uncertainty quickly goes down, after 10 measurements:
   assert(0.0013 - 0.0001 < k.p() && k.p() < 0.0013 + 0.0001 &&
diff --git a/sample/rocket_altitude.cpp b/sample/rocket_altitude.cpp
index 580de3bbb..98e2ec680 100644
--- a/sample/rocket_altitude.cpp
+++ b/sample/rocket_altitude.cpp
@@ -100,65 +100,65 @@ namespace
 
   // The measurement values: z1 = -32.40, u1 = 39.72.
   // And so on, every measurements period: Δt = 250ms (constant, as variable).
-  k.observe(-32.40);
+  k.update(-32.40);
   k.predict(delta_time, 39.72);
-  k.observe(-11.1);
+  k.update(-11.1);
   k.predict(delta_time, 40.02);
-  k.observe(18);
+  k.update(18);
   k.predict(delta_time, 39.97);
-  k.observe(22.9);
+  k.update(22.9);
   k.predict(delta_time, 39.81);
-  k.observe(19.5);
+  k.update(19.5);
   k.predict(delta_time, 39.75);
-  k.observe(28.5);
+  k.update(28.5);
   k.predict(delta_time, 39.6);
-  k.observe(46.5);
+  k.update(46.5);
   k.predict(delta_time, 39.77);
-  k.observe(68.9);
+  k.update(68.9);
   k.predict(delta_time, 39.83);
-  k.observe(48.2);
+  k.update(48.2);
   k.predict(delta_time, 39.73);
-  k.observe(56.1);
+  k.update(56.1);
   k.predict(delta_time, 39.87);
-  k.observe(90.5);
+  k.update(90.5);
   k.predict(delta_time, 39.81);
-  k.observe(104.9);
+  k.update(104.9);
   k.predict(delta_time, 39.92);
-  k.observe(140.9);
+  k.update(140.9);
   k.predict(delta_time, 39.78);
-  k.observe(148);
+  k.update(148);
   k.predict(delta_time, 39.98);
-  k.observe(187.6);
+  k.update(187.6);
   k.predict(delta_time, 39.76);
-  k.observe(209.2);
+  k.update(209.2);
   k.predict(delta_time, 39.86);
-  k.observe(244.6);
+  k.update(244.6);
   k.predict(delta_time, 39.61);
-  k.observe(276.4);
+  k.update(276.4);
   k.predict(delta_time, 39.86);
-  k.observe(323.5);
+  k.update(323.5);
   k.predict(delta_time, 39.74);
-  k.observe(357.3);
+  k.update(357.3);
   k.predict(delta_time, 39.87);
-  k.observe(357.4);
+  k.update(357.4);
   k.predict(delta_time, 39.63);
-  k.observe(398.3);
+  k.update(398.3);
   k.predict(delta_time, 39.67);
-  k.observe(446.7);
+  k.update(446.7);
   k.predict(delta_time, 39.96);
-  k.observe(465.1);
+  k.update(465.1);
   k.predict(delta_time, 39.8);
-  k.observe(529.4);
+  k.update(529.4);
   k.predict(delta_time, 39.89);
-  k.observe(570.4);
+  k.update(570.4);
   k.predict(delta_time, 39.85);
-  k.observe(636.8);
+  k.update(636.8);
   k.predict(delta_time, 39.9);
-  k.observe(693.3);
+  k.update(693.3);
   k.predict(delta_time, 39.81);
-  k.observe(707.3);
+  k.update(707.3);
   k.predict(delta_time, 39.81);
-  k.observe(748.5);
+  k.update(748.5);
 
   // The Kalman gain for altitude converged to 0.12, which means that the
   // estimation weight is much higher than the measurement weight.
diff --git a/sample/vehicule_location.cpp b/sample/vehicule_location.cpp
index af015438c..cf53f2b5e 100644
--- a/sample/vehicule_location.cpp
+++ b/sample/vehicule_location.cpp
@@ -81,77 +81,77 @@ namespace
   k.r(kalman::output_uncertainty{ { 9, 0 }, { 0, 9 } });
 
   // The measurement values: z1 = [-393.66, 300.4]
-  k.observe(-393.66, 300.4);
+  k.update(-393.66, 300.4);
 
   // And so on, every measurements period: Δt = 1s (constant, built-in).
   k.predict();
-  k.observe(-375.93, 301.78);
+  k.update(-375.93, 301.78);
   k.predict();
-  k.observe(-351.04, 295.1);
+  k.update(-351.04, 295.1);
   k.predict();
-  k.observe(-328.96, 305.19);
+  k.update(-328.96, 305.19);
   k.predict();
-  k.observe(-299.35, 301.06);
+  k.update(-299.35, 301.06);
   k.predict();
-  k.observe(-273.36, 302.05);
+  k.update(-273.36, 302.05);
   k.predict();
-  k.observe(-245.89, 300);
+  k.update(-245.89, 300);
   k.predict();
-  k.observe(-222.58, 303.57);
+  k.update(-222.58, 303.57);
   k.predict();
-  k.observe(-198.03, 296.33);
+  k.update(-198.03, 296.33);
   k.predict();
-  k.observe(-174.17, 297.65);
+  k.update(-174.17, 297.65);
   k.predict();
-  k.observe(-146.32, 297.41);
+  k.update(-146.32, 297.41);
   k.predict();
-  k.observe(-123.72, 299.61);
+  k.update(-123.72, 299.61);
   k.predict();
-  k.observe(-103.47, 299.6);
+  k.update(-103.47, 299.6);
   k.predict();
-  k.observe(-78.23, 302.39);
+  k.update(-78.23, 302.39);
   k.predict();
-  k.observe(-52.63, 295.04);
+  k.update(-52.63, 295.04);
   k.predict();
-  k.observe(-23.34, 300.09);
+  k.update(-23.34, 300.09);
   k.predict();
-  k.observe(25.96, 294.72);
+  k.update(25.96, 294.72);
   k.predict();
-  k.observe(49.72, 298.61);
+  k.update(49.72, 298.61);
   k.predict();
-  k.observe(76.94, 294.64);
+  k.update(76.94, 294.64);
   k.predict();
-  k.observe(95.38, 284.88);
+  k.update(95.38, 284.88);
   k.predict();
-  k.observe(119.83, 272.82);
+  k.update(119.83, 272.82);
   k.predict();
-  k.observe(144.01, 264.93);
+  k.update(144.01, 264.93);
   k.predict();
-  k.observe(161.84, 251.46);
+  k.update(161.84, 251.46);
   k.predict();
-  k.observe(180.56, 241.27);
+  k.update(180.56, 241.27);
   k.predict();
-  k.observe(201.42, 222.98);
+  k.update(201.42, 222.98);
   k.predict();
-  k.observe(222.62, 203.73);
+  k.update(222.62, 203.73);
   k.predict();
-  k.observe(239.4, 184.1);
+  k.update(239.4, 184.1);
   k.predict();
-  k.observe(252.51, 166.12);
+  k.update(252.51, 166.12);
   k.predict();
-  k.observe(266.26, 138.71);
+  k.update(266.26, 138.71);
   k.predict();
-  k.observe(271.75, 119.71);
+  k.update(271.75, 119.71);
   k.predict();
-  k.observe(277.4, 100.41);
+  k.update(277.4, 100.41);
   k.predict();
-  k.observe(294.12, 79.76);
+  k.update(294.12, 79.76);
   k.predict();
-  k.observe(301.23, 50.62);
+  k.update(301.23, 50.62);
   k.predict();
-  k.observe(291.8, 32.99);
+  k.update(291.8, 32.99);
   k.predict();
-  k.observe(299.89, 2.14);
+  k.update(299.89, 2.14);
 
   assert(5 - 0.0001 < k.p()(0, 0) && k.p()(0, 0) < 5 + 1.84 &&
          5 - 0.0001 < k.p()(3, 3) && k.p()(3, 3) < 5 + 1.751 &&