0:01

Now that we have a model of the CPS that is given by a combination of

differential equations and inclusions

with difference equations and inclusions on potentially constrains,

we can now think about the definition of an execution or a solution.

Let's derive a formal definition for that.

Let's recap, a CPS is given by the combination of differential inclusions or equations.

I will stick to the inclusions case,

so we remember the general formalism,

but you can replace that by any equality sign.

And I will consider the case of no inputs.

I would make a remark about the case of inputs shortly.

Those are the differential inclusions with constraints for the continuous change.

Then, whenever the events occur,

we're going to capture these as a condition of the state on

subset of the state to space, the jump set.

Remember that this is the two conditions defining that.

This is the flow set.

This is the jump set.

This is the jump map.

And this is the flow map.

This will define our CPS without inputs for the time being.

The notion of time was already defined.

We're going to use hybrid time.

We're going to have t and we're going to have j.

We have these pairs, t,j's,

that define our notion of time.

And at every value of t and j in a particular domain,

which we call the hybrid time domain,

which has a particular structure as I already defined,

we can characterize what a solution or an execution to the system would be.

Let's think about this informally for a minute.

The basic idea is that

during the continuous motion or the continuous evolution, so during flows,

solutions are governed by

x in F of x, x in C. This

boils down to what is called a differential inclusion.

In the case of an equality,

will be stressed an autonomous differential equation with a constrain.

During the jumps or at jumps,

solutions are governed by

the following difference equation or inclusion with constraints.

It is natural to expect that if I have an interval flow,

then I will be looking at intervals, let's say,

of the form t_j,

t_j plus one with

non-zero length over which

I will need to have this condition being satisfied.

And I would say that the trajectory derivative

is in the set F, and its value is in the flow set.

You need to satisfy this condition which is here.

I need to satisfy this other condition which is here.

5:36

In such a case, what we need to now guarantee is that at the jump time,

which is t and j,

and after the jump time, which is t and j plus one,

this expression is being satisfied.

Basically, what we are saying is that the trajectory at

t,j plus one belongs to G,

while at t,j belongs

to D. That is the structure that we're looking for.

And in order to define what a solution is,

we need to put further properties on the function.

We are given hybrid time.

We're given trajectories given by hybrid arcs.

We're going to, in general,

define as a functional phi which has a domain or definition phi

and its values take from where to the space of the system would be.

Let's assume that x here is an element in R_n.

I grab a hybrid arc where this domain is a hybrid time domain,

has the main structure that was introduced in the previous video.

And remember that we need to be able to take derivatives of

this function every time we fix the j so that

this particular property is satisfied, okay?

How can we formalize these properties?

This is an informal definition.

Now, I'm going to write down here the formal definition.

A hybrid arc is a solution or

execution to the CPS

8:04

if the following properties hold.

And we're going to have three properties here.

We're going to write two here and then the other one here.

The first property is that the initial value of the hybrid arc

belongs to the original for operation.

The system can evolve in C or D.

We will guarantee that

these initial value of that function is where I can flow or where I can jump.

Now at times, this set C is not necessarily

a close set and we would like to allow the trajectory to flow into the flow set,

in which case, we will be able to add there a bar and close the set.

Every time that there is an interval of flow,

like I say we find it here,

what I would like to say is that this interval which I define

here as i to the j having known empty interior or non-zero length,

I will have the property that on these I_j's with such a property,

I will have the derivative of the function of phi with respect to

time belongs to F and t,jl.

I'm more aware that I will have that its value belongs to

C. That will be the condition that captures

this property that I have

essentially a solution to the constrained differential inclusion.

And as we describe here for these elements t and j,

such that I have a jump so therefore,

t and t,j plus one is also an element in the domain,

I will need to have the property that if t and j,

and t,j plus one in the domain of phi,

we have that whenever we jump,

the new value belongs

to the image of a jump map evaluated when I jump and suddenly,

this value needs to belong to D. There are,

basically, three conditions that

these arcs that are hybrid will need to satisfy in order to have a solution.

Those conditions are written down here informally.

There are subtleties about whether

these should hold on the open or on the close interval,

and you can look at the references for that with those details.

But the main point is that every time that there is an interval of flow,

we should be able to take a derivative with respect to time and satisfy

the differential constrain with the inclusion or the equation.

And every time that there is a jump,

we should be able to guarantee that the value of the solution after the jump is given by

an element of the solution where the jump map is evaluated at,

and whenever the jump occurs, where in the jump set.

Now, we can consider different cases of CPS,

and I will provide one shortly,

where you can actually compute specifically and

analytically the solution to a system and then write down these arcs.

In many other cases,

you can't do that but you can have a generator of these executions numerically that will

actually give you the approximated execution

to your system from a given initial condition.