In some cases when we have a algorithm that we would like to implement in the cyber component, we actually have it in continuous time. We have let's say, a continuous time controller, an estimator, or some other process that is designed in continuous time, and we would like to implement in the cyber component. So we need to go from continuous time, which is where the algorithm comes from, to discrete time. In that case, the cyber component will be actually given by a discrete-time algorithm that is executed every so often. And let's say that that is often and is given by a constant T_star. So the way we can go about such implementation is to recall the state space form of a continuous-time model which we did for the physics and then we are going to call them with a sub-index k instead of p to these matrices, and suppose that this is the form that we have. The idea is that if we sample these every T_star seconds, we're going to arrive to a model that will be given by the following expressions. So we want to put this into the cyber model and we have been using these variable eta. So we want to use eta plus, and then the output will be this theta, the input would be p. Turns out that because this is linear, actually linear time invariant, these matrices will actually have explicit form that depends on the previous matrices in continuous time and the variable that you picked for time. These expressions can be derived using the expression for the solution to a linear time invariant system given an initial condition and an input that we saw in a previous video. So now with this discretization, if we were to have a solution to my continuous-time system, which is an algorithm, then this particular discretization will provide values of this state which we call eta at every T_star. So the idea is that from going from continuous to a discrete model, that in this case is periodic, we arrived to a model of a cyber component that implements a discretization of the algorithm and performs pretty closely to what the continuous-time model would be. Again, these will allow to implement discrete versions of continuous-time controllers, estimators and so on.