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.