So at times the cyber component has algorithms that only perform computations, and we may want to model those computations using a mathematical model. For that, we can actually compute things using just a static map. If the output of the cyber physical system, cyber component, is a [inaudible] theta, and the input to it is v, then we might just need to find a map which we are going to call it Kappa tilde. In this case, we say that that one shot computation can be modeled as the evaluation of the map Kappa tilde as follows. So the input to this static map or system, this is the input, this is the output. The input is provided, you evaluate this expression, and then you generate an output. An example that is very common in control systems is the case of a proportional feedback. Which in this case, leads to a map Kappa of v that is equal to some constant, let us call it capital K times the input v. And that constant can be actually a matrix when the input is a vector. In other cases, we may need to use iterative computations. So we may have multiple iterations to arrive to a result. If we assume that we have finitely many iterations in order to arrive to a result, then we can use the following model. So the idea is to have first, a variable that keeps track of the iterations. So we will have a variable k that will count the position in my multiple iterations that I'm currently at. And every time that there is an iteration, that variable is going to be incremented by one. Assuming that the finitely many iteration is labeled as a constant k*, then these increment will occur if k belongs to 0,1, all the way to k* minus 1. And when k is equal to k*, then we will keep it at that particular value. So this is how the update law of k would be. At every iteration, we might have a result of a computation that we may need to use in the next computation. For that purpose, we will have a variable m, that is a memory state that stores the computation that has been done with a previous value of my computation or the previous result, and depends on the particular iteration step that the computation are at, and it certainly will depend on the input that is applied to the system. And in this case, we can also, with some obvious annotation, use a map K, Kappa tilde in order to rule this computations. And this will be performed if k belongs to this set. So after k* operations, we will just complete our computation, and this particular system, similar to this, could be thought as a static map with multiple evaluations, and this will be in this constant. If this cyber part is only doing computations, this will be the type of models that we can consider. Certainly, there are more complex models that one can find for modelling the computation of a system, and those might be able to befit into these type of models as long as the number of iterations are finitely many.