0:02

Given a CPS in terms of differential inclusion or equation with constraints,

and difference inclusions or equations with constraints,

we can now define the notion of solution or

execution to the systems using the following construction.

The first thing we want to define is the notion of hybrid time.

As we mentioned earlier,

we will use two parameters: the executions

will be parameterized by

one parameter which is t ordinary time taking

values on non-negative reals which is this set.

And this would be for the flows or continuous change of your trajectories or executions.

While every time there is an event,

we're going to define j as the counter of events and

that counter would take values in the set of naturals including a series.

An execution, now will be

for as a function,

we'll call it in general phi,

defined on a hybrid time domain.

2:01

When you define a function,

you can specify the domain of the function as

dom of the function and it's co-domain in this case,

since we're thinking about CPS with states that take generic dimensions,

say n dimension, we will say that the co-domain is R_n,

could be much smaller than that.

You can make it tight.

This is the domain of the function.

This domain is what we're going to give some structure which is

what we call hybrid time domain.

This function for the domain such that the following holds.

For every element in the domain,

let's call them capital T and capital J,

be an element, define an element on this domain,

3:14

we have that the domain of that function intersected with a box

of size ([0,T]x{0,1...J}) can

be written as the union of intervals of flow if we have non-zero length index by j.

Now, these intervals of flows will be given in terms of

a sequence of elements that I'm going to a label as t_j,t_j+1,

two consecutive elements where

t_j satisfy the following properties: t at j equal to zero is equal to zero,

t_1 is larger or equal than zero,

t_2 is larger or equal than t_1, and so on.

This will go to up to some t. This will be from j equal to zero.

And if we would like to get all the way to capital J,

this would be the final element in

which case the last element on the sequence will be t capital

J plus one,

4:44

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.