 Thank you very much for being here until so late. I will try to keep it light. This is a joint work with Alessandra Lafaita from the University of Venice and it is about minimization of a true concurrent model, which are even structures. I will spend some time in giving a context to the work to explain what I'm talking about. First of all, I'm talking about true concurrency, which is an approach to the semantics which is normally opposed to the inter-living approach, where concurrency is not a primitive notion, but rather concurrency of actions is reduced to the nondeterministic choice between the possible inter-living. The possibly most simple example to explain the difference is the following. On the one hand, you have a system consisting of two parallel components, one executing an A-action and the other executing a B-action. On the other side, you have a sequential system which chooses nondeterministically between A followed by B or B followed by A. In an inter-living approach, these two are considered equivalent, which is quite reasonable. If you close the system in a box and you are only able to observe the currents of actions from outside, then you will see the same thing, either A and then B or B and then A. In a true concatenate approach, these two are considered different, and depending on what you can observe, these are for good reasons. For instance, if you can observe parallelism, here you have two parallel components, here instead you have a single sequential component, or if you can observe some dependency between actions, some causality, then here the two actions, A and B, are totally independent. Here, if you choose the left branch, then you will have B, necessarily follows A, which suggests the presence of some dependency. In the true concatenate model, we are focusing on even structures which represent the dynamics of a system in terms of a set of events or currencies of actions which can occur in computations, and dependencies between events. There is a prime event structure which will play a role in the presentation on a particularly simple and popular model where the dependencies between events are captured in terms of two relations, causality, the fact that some events are needed for some others to occur, for instance, because they produce something which is used by later events, and conflict which says that some events cannot stay in the same computation, because they try to consume the same things. This is a very simple example of an event structure with seven events. E1 is a cause for E3, meaning that you can execute E3 only after E1. E1 and E2 are in conflict, meaning that you can't execute both E1 and E2 in the same computation. E1 and E5 are totally unrelated, which means that they can occur in any order and possibly concurrently. Typically, events are labeled to represent the fact that there are occurrences, instances of the same kind of action, for instance. This is a rough representation of part of the process of going to a conference. You have to reach the airport, and for reaching the airport, you first need to either to take a taxi or train, imagine you do only one of these two things, or these two are in conflict, and then you have two occurrences of the airport action, one which is dependent on taxi, and one which is dependent on train. Totally in parallel with this, you have to get a visa, and you could maybe get it immediately, or you could meet first a declaration. Also, in this case, you have two instances, two events labeled by visa to represent the fact that you have two ways of getting the visa. Normally, in the pictures, I will name events with the label and some subscripts. For instance, airport 0 and airport 1 are two events with the same label airport, but they are two different events. Then in event structure, the notion of computation is captured by the idea of configuration, which is a set of events, configuration is a set of events, which collect all the events which happened up to a certain point in the computation, and they have, depending on the kind of event structure, several calculations, for prime event structure, they are just simply causally closed and conflict-free set of events, meaning that if you have an event, you need all the causes, and you cannot have two events in conflicts. For instance, in this simple event structure, you can start from the beginning, no events, then you could execute the taxi event, which has no causes, and you get to this configuration, then you could execute the visa 0 event, which has no causes. These two could be even executed in parallel, and now, since you executed taxi, you have airport event enabled, airport 0, and you can execute this kind of a sequence of configurations that you can generate. There are, in the literature, something which is also relevant to our discussions, that in the literature, there has been several proposals of event structure, which generalize prime event structure, providing some more expressive constructions. For instance, flow event structures replace the causality relation by a flow relation, which allows to express the presence of conflict or disjunctive causes. In prime event structure, if you have two events in conflicts, which cause the same kind of action, then you have to put two events for them. Instead, in flow event structure, this is a very simple example, you can have this event, which has two flows, taxi and train, and the idea is that in order to enable an event, you need to first execute a maximal consistent subset of its flows. In this case, you have only two events in conflict, so maximal consistent subsets are just single events, taxi and train. Each one of these two is sufficient to enable airport, which is a slightly more compact representation of what you can get with the prime event structure. There are several other proposals that I will not spend time on that, but just mentioned, for instance, you have asymmetric infrastructure where you can represent the situation in which you have an event, which have an optional cause, like this, with the primitive construction, what it is doesn't really matter, but you can have something more compact. And then the idea of this work started when I met some people from the process mining community, and they were trying to construct from logs a representation of processes of which they had the logs, and specifically they were extracting process models in the form of event structures. For instance, this could be something that they got out of a set of logs representing the process of going to a conference, and if you add also the last step, when you have the airport, you are at the airport, you get the visa, you can move to a conference, you have four more events representing the act of going to the conference in all possible ways, having got the airport via taxi, having got the airport via train, and having got visa immediately or after the declaration. And their question was, can we get smaller representation, maybe because there is some redundancy, or maybe because I want to move to some more expressive event structure model, so can we compact the representation but keeping the concurrent behavior unchanged in some sense? And I suggested, okay, but what you want is a quotient, this is your original model, you want to quotient it into a smaller one via some kind of morphism, which merge some events into one, but this must be not only a simulation, but some formal concurrent by simulation. And as I just looked it up in the literature, you will find probably many techniques for this. And apparently there were no, and so we did some ad hoc work for their needs, which was kind of working, for instance, if you want to start from here and you want to work with flow, even structured, you can get to this. But still there were several, okay, it was kind of ad hoc working on specialized cases, and so the idea was, can we get a more general, more disciplined theory of behavior preserving portions for event structure, for instance, is the notion of folding as we define adequate for expressing behavior, all behavior preserving portions, does there exist a minimal quotient in some class of event structure, maybe a general one collecting all the possible models or does this result carry out in specific subclasses? Can we have a characterization of what is a folding without generating the transition system of configuration so directly on the structure of the event structure? And these are some of the questions which we tried to address here. First of all, we work to avoid to be tightly linked to a specific kind of event structure. We work on a general model, which was available in the literature, which are positive structure where configurations are not induced by some dependencies between events, some notions of dependencies between events, but they are primitive, they are given. So a positive structure is just a set of events and a set of pomset that can be executed there. So this could be an example, three events, and then you say these are my possible configurations, A, C, alone, A alone, C alone, empty configuration, B alone, A cos in C, A in parallel with B, B cos in C. Okay, there are some prefix closureness requirements, and the idea is that this represents the evolution of configuration goes from any configuration to another one whenever the first one is a prefix of the second. So for instance you go from the empty one to A, you can go from A to AC, but for instance you can't go from C to AC because here A is a cos of C and moving from here to here would be inserting something in the past of C. The nice point of positive structure is that most common stable event structure in the literals can be seen as special positive structure. You can view prime event structure as such, flow event structure, which I mentioned before, the boundary event structure, which has another way of expressing destructive cos, the asymmetric event structure also is an instance. So we decided to work here. Okay, to portion with respect to have a behavior or preserving portion, you need a notion of behavioral equivalence, which took some kind of standard notion in the setting of concurrent system, which is a redditor history of preserving by similarity, which is a variation of by similarity, where not only you ask that any action of a system is simulated by an action of the other system with the same label of the same nature, but also you ask that the dependencies with respect to the past of these two actions are the same. This is the form of definition, but just keep it, I think that the intuition I gave you is enough for this time of the day and for what we will see. And this is kind of a graphical representation. So these are the two systems, and they are corresponding evolution. So not only when I move from some state of the system to another state of the system, I must be able to do the same here, but also the causal links with respect to the other events which happened must be the same in both cases. Getting back to the original example of two parallel components, A and B, or the non-deterministic choice between A, B and B, A, these are not by similar with respect to that notion. You don't need such much expressive power for distinguishing the two, but this is just a simple example. And the reason is that you can do A in both cases, but then the second system can do a B action which is causally dependent on A, and this is not possible for the first one, which can just execute a B which is independent of A. So these are the ingredients and the notion of folding, start by defining first the notion of morphism between even structure which is just a mapping from events of the first even structure to event of the second even structure which transforms configurations into configurations. This would be just a simulation. You need more to say that if you quotient with respect to F, you preserve the behavior. Well, okay, you need subjectivity, and also you need the fact that if you take configuration of one system and the image, the pairs consisting of a configuration of one system and its image on the other side, then this is HHP by similarity. But, okay, intuitively it just means that the function is merging events without affecting the concurrent behavior. You can view it differently. A subjective morphism can be seen as an equivalence, which says that three events are equivalent if they have the same image. And then, if this is a folding, then taking the original even structure E or its quotient with respect to such equivalence, you got to buy similar things. A very simple example. Here you have a prime even structure, but it is intended to represent, is a graphical representation of a positive even structure. And you see that you have these two instances of A in conflict. Both causes a B. And these two branches, which are alternative, are in the same relations with all the rest. And maybe it's intuitive even though I didn't give any definition that you can merge safely these two. So this is a folding. So the first question was, is the notion of folding adequate? Is it the case that any function which perform a behavior preserving quotient is a folding according to that definition? Strictly speaking, no. If you take this function, which just merges A1 and A2, this is not a folding, roughly because if you execute A12 here, you have to simulate it here by one of these counter-images. But if you choose this one, you can choose B2, which you cannot do here. And if you choose A2, then here you could choose B1, which you can't do here. But in this case, and actually this is a totally general fact, you can consider, whenever you have a situation like this, there is an even more quotient even structure, such that there is a folding from the original one to this one. So you don't capture behavior preserving quotient by a folding, but whenever you have a behavior preserving quotient, you have a coarser one, a smaller one by a folding. The other question was, do we have a uniquely determined minimal representation of a concurrent behavior, uniquely determined minimal quotient? The answer is positive, and the key observation for this is that if you have an even structure, and two ways of folding it, so here you're just taking some merging some events, you're merging some others, maybe with some intersection, and then it is always the case that you can close this diagram and get an even structure where you do all the merges that you did on the left and on the right, which formally, okay, I would just pick only a couple of times to this categorical aspect, you can view even structure with folding as a category, and this says that you have the corresponding category as pushouts. A very simple example. If you start from here, you could merge these two instances of B into one, and these two instances of B into another one. This is a possible folding. You could merge a one, just trust me, okay, maybe it's evident, maybe not. You could merge a one and a two into a single event, these two B into a single event, and these two blue Bs into a single event. This is also a folding, and then according to the result, before you can do all the merges and you would still get the fold. Having just pairwise joining a folding wouldn't be sufficient, but you can actually prove that this ought for any number of co-initial foldings, which leads to the fact that if you take the lattice of equivalences of an event structure and then you consider the sub-lattice consisting of the behavior-preserving equivalences, those induced by foldings, then this is a complete sub-lattice, which means that you have a top equivalence, which is the one which is taking the smallest portion. Given any positive event structure, there is a maximally-folded version. For the last point, characterizing foldings, a key point here is the observation that given a positive event structure, you can turn it, you can associate to it a prime event structure such that the original event structure is the folding of the prime event structure. So you can unfold, say, any positive event structure into a prime event structure, and then you get this folding from the prime to the posit. How you can do this, maybe it's not so important, but try to give a big idea. You start from the positive instructor, you take the configuration which has a maximal element, which roughly represents all the different ways of executing a single event. For instance, for C, you have three ways of executing C, caused by A alone or caused by B. This becomes the events of the prime event structure, and then causality is prefix and conflict is consistency in this partial order. Okay, it's not really important. Just remember that for any positive structure, you can get a prime event structure. And now if you take a morphism of positive event structure, you can construct the corresponding prime event structures, which are connected to the original event structure by a folding, and you can take also the image of this morphism over here, and you can prove that F, the original morphism is a folding if and only if the morphism over a prime event structure is a folding, which means that you can transfer the study of folding from the general setting of positive event structure to the simpler setting of prime event structures. And then the last step is having a characterization of folding on prime event structures, which can be done. I won't comment too much on that. These are just conditions which says that the morphism must be well behaved with respect to labeling and causes with respect to conflicts and with respect to concurrency. I think it's not really worth to go into the details of the conditions, but I just observed that this is given directly on the event structure without generating the transition system of configurations. Finally, one could wonder if the existence of... some properties that we have seen before carry over when we restrict to sub-sets, sub-classes of positive event structure. For prime event structure, everything works well. For instance, you still have a maximally-folded version. For this prime event structure, it's maximally-folded version in the setting of prime event structure. This is not maximally-folded in the setting of positive event structure. You could still fold B3 and B12. While instead, things work less well for other sub-classes for flow event structures and also for asymmetric event structure than skipping this. So getting to the conclusions, we get some initial answers to the questions that posed at the beginning. For the future, some interesting direction of work could be some more abstract and general characterization of the results presented here. From time to time in the paper, you can find more. I pointed out that the fact that several conditions have been natural categorical interpretations, in particular, foldings can be characterized as open maps in the sense of Joja, Nilsa, and Viennskill, something which suggests that one could give a more elegant, abstract, and possibly general presentation of the result, which is applicable not only to... which is making evident which are the e-credits which makes things work. Up to now, okay, I have an idea, but it's not really so explicit. From a practical point of view, one could try to use the characterization we have seen before to derive folding algorithms given a path to determine its quotients or given a possible quotient, candidate quotient, verify whether it is. For finite primary structure, this can be done more or less directly by using the previous characterization, but a direct, naïve checking based on the characterization would be extremely inefficient. I think one can do much better. Another point, okay, if you have infinite infrastructure, you can do it very much, but infrastructure are a semantical model where other models, operational model maps, and you could think of exploiting the theory here to study a notion of folding on operational models, so a portion of operational model which translates to foldings of the corresponding semantics when you take any of the structure semantics. Yeah, for instance, okay, right. It's great to think that first when fold and then fold. When you directly, other than foldings of direct or fact guaranteed is maximally folded. Yes, yes, yes, this could be, this is kind of the idea underlying this. Last point, so if you want to, you have a safe patternet and you want to know whether you can do some quotient there which does not alter the concurrent behavior, this you could characterize by saying that you take a portion of the patternet such that since the unfolding is a functor, you take the image for the unfolding functor of this quotient, this should give a folding in the sense of defining this paper. If this happens, we are sure that the operation that you did on the patternet doesn't affect the concurrent behavior. So this would be exactly, it's not that first you unfold and then you fold, but rather you fold the patternet and you check that what you get at the semantical level is a folding. This would be the idea. Thanks. The portion thing and the minimal portion. So the minimal portion is unique. Is it unique? Yes. So you talked about the existence of the minimal portion and does there also exist an algorithm to find the minimal portion? Well, as I was mentioning, if you limit yourself to finite even structures, then yes, but this is maybe, okay, the existence of an algorithm is not interesting. Finding an efficient algorithm could be, because up to now if you just use the definition is just checking that some candidate folding is a folding is exponential. So, and you should, okay, the naive approach could be just to enumerate the possible portion, but these are really too much. And okay, it is obvious that this is not the best way to do. But so, yes, it would be interesting to find an algorithm which efficiently, whatever it means, which improved the naive algorithm. Essentially, the algorithm that is used for regular misimulation, so those algorithms can be adapted to your portion of portion team. Really? But because, okay, you could take a different approach and map your system to a regular transition system. This is done, for instance, in several works about history dependent automaton, nominal automaton and so on. You can do that. After you move to a standard transition system, there you can use standard tools, but then you can't go back to the concurrent model. So, instead here, maybe it can be done. I don't say no, but it's not totally not obvious to me if and how. Thank you. Okay, this is it. Thank you very much for the attention.