is some sequence.

In other words, we need to have an ordering of

the events of flow and jump and that ordering is given by this sequence.

Now, we can think about a particular execution.

Let's say for a problem where you have

a timer that the timer counts to a particular number,

let's say one, and then you get through set to zero, and so on.

In that situation, the example that we're thinking will lead to a function, phi,

that we'll define on t

given by the following possibilities.

If the timer says start at zero then counts linearly to one,

we will have this whole interval from t_0 equals zero to

t_1 equal one as a time where the system flows,

and this will define zero to one in this particular structure.

This will be for j equal to zero.

When the jump occurs,

what's going to happen is that j is going to be incremented.

We're going to go to another value of j,

at which we will have another interval of

flow for this particular system that we're thinking of that will go all the way to two.

And you can continue this structure and keep increasing your j

after one second of flow, so this continues.

This structure that you see right here is a hybrid time domain because it's

defined for a sequence given by j precisely for the t_j's.

And every time that there is a recent event,

the j is incremented and leads to a structure like this.

You can validate that by picking a particular element, t_j.

Let's say, this is t and this is j,

and you pick this particular element,

now you can write down this whole box that is left behind

as the union of intervals from zero to one for flow across zero,

union with one to two cross one for j equal one,

and then two to wherever capital T is across with two for a particular last piece.

Notice that this structure needs to

be possible whenever you pick an element in the domain.

And this allows you to now think about situations where

the end point of this time domain is open,

where, in that case,

you will not be able to pick the right most element because it's open.

But in any element on that domain,

you will actually be able to regulate this.

It allows you to have a particular trajectories that are not already defined at t equal

three j equal two maybe because of blob or

maybe because of other difficulty on extending the solution.

That's the structure of time.

It covers ordinary time when j is always to zero.

It covers discrete time,

not necessarily with the discretization when t is equal to zero.

In our case, covers the hybrid case.

What you can now think about is what kind of executions you could have to your system,

and it turns out that some type of executions can be

determined by just studying the hybrid time domain of execution.