 So we hope that we can keep this schedule and that means the coffee break will be starting ten minutes later and will be ten minutes shorter so that we are back in time. And to keep it short, I will just introduce you an old friend of mine, Nicolas Bredesh is going to tell you about evolution in collective robotics. Okay, so thank you, thank you for the introduction. I would like to first start by thanking the organizers, so far it's a really great conference for me because I'm not really from the fields which have been presented so far, so I've learned a lot and so thanks. I'm going to discuss about embodied evolution in collective robotics. So my original field is computer science and I work in a laboratory which is in between biological modeling, robotics and artificial intelligence. So it's a lab in Sorbonne University which is in the center of Paris. So the basic idea of what I'm interested in is illustrated in this picture. So the basic idea is that we have this bunch of robots which are in a box. We want to put the box in some environment we don't know and we want to release the robots and want them to be able to figure out what is to be done given that we have defined a loose objective, for example, gather some objects or explore the environment and the challenge is due to the fact that you don't know at first what the environment looks like, what you must do to actually complete the task. So there are many things that you discover once you are already in the environment. So to define a little bit further the class of problem I'm interested in, it's problems where there is a high level definition of the objective. For example, you define that you want to get your robots to forage items in the environment but you're not capable of defining how they should do it. You don't define the behavior that they should do it. So you have a very loosely defined metric that gives you an idea of how good it is performing, how good the swarm is performing and how good it is performing compared to what it did previously. I consider also robots which have limited capabilities, that is they have limited communication, meaning that they can't send that many messages and that they can only send these messages in the neighborhood of, in their neighborhood. And also I assume that these robots have limited computation power. So it's not possible to wait for the whole robot to synchronize to make decisions. And really this is a decentralized robotic setup. And last year I consider open environments that is an environment where you don't know a priori what the environment looks like and there is no teacher that is capable of helping you once the robots are deployed in the environment. So this is a quite specific problem setting of course and what we've been doing for experimenting with this kind of problem, well to do our tests, to do our research, we mostly work in simulation and also we work with several kinds of robots, of swarm robots. So these are examples of what I'm doing. So here you can see an image of a team of robots extended with Raspberry Pi, which are working in the lab. Also of kilobots, which is the second picture, which you have already seen in other presentation. And lastly we also use microbeads, which are micrometer beads, which we functionalized with biomolecules so that they can send and receive message and they move just by a Brownian motion and stop by being attached to one another. So I want to really discuss these robotic aspects in my presentation. I will show a little, some video of robots, but mostly it will be simulation because in terms of methodology, what we do is once in a while we go to the real robots to be sure that we are not doing something which is out of the simulation, which is just out of focus with respect to the real problems we want to achieve, to tackle. But also we do a lot of extensive experiments to really understand the way the algorithms are working. So the thing is that when you are in front of this kind of problem, there are not so many methods that you can use. It's a learning problem because you want to tackle new, well you want your swarm of robots to be able to acquire new behaviors that will be defined by how the environment is. There is a strong influence from the ecological aspects of where you are. So the goal is to design, my goal is to design lifelong learning algorithm, lifelong because the environment may change through times for these swarm of robots, that means in a decentralized distributed system. So as I said, there are not many methods that can be used in this context. Reinforcement learning for multi-agent system is quite limited. Usually you've got some nice theoretical results but it cannot be implemented in the real world. Or when you implement things in the real world, these are very simplified learning methods which have nothing to do with what is developed in the theoretical framework. So there are pros and cons for this. One approach which is quite efficient, which is a good candidate, is evolutionary robotics. So evolutionary robotics combines, well, apply evolutionary computation, evolutionary optimization for optimizing the controllers of robots. So it has been introduced quite some time ago in the 1990s by several people, including some people who are actually in this room. So I guess you will recognize yourself. And this is very efficient because it's a stochastic optimization method. That is, you don't have to know that much about the objective to tackle. You have to get a loose definition of the objective in terms of a fitness function. You can manipulate some very exotic representation where you can explore exotic representation space. So it can be parameters but it can also be structure. And it gives quite good results. These are materialistic, so it gives approximate results. So this is quite fitted for swarm robotics and learning in swarm robotics, but yet it is not really applied to online robotics. So just for those of you who don't know how it works really quickly, you start with an initial population of candidate solutions, which can be parameters of a control model. Then you evaluate these candidate solutions in simulation or on the real robots. Then you can rank these different solutions in terms of the performance that the robot achieved with these parameters. And then you operate a selection and then variation of these solutions in order to select mostly the best of the solution so far and to build new solutions which are more or less closely related to the previous solution. Then you replace your population of candidate solutions and then you start again and you iterate until you've exhausted your budget or you've reached a satisfactory solution. So the next step is how to adapt this in a distributed setup for online learning. And this is possible thanks to another framework, which is an extension, which is an instance of the original evolutionary robotics framework, which is called embodied evolution. So it has been introduced by Richard Watson some less than 20 years ago. And it has been well developed quite a lot in the last 10 years. So the idea is that you still take this evolutionary computation machinery but you put it in one robot. And these robots, each robot will run an optimization algorithm. But then what you will do, what you will modify is that you will add communication, you will take communication into account and each robot will spread its own parameters, its own genome to nearby robots during the different encounters. And after some time, the genomes that you have received, the parameters that you have received, you will run an evolutionary algorithm based on the fitness values of these different received genome and then select a new genome to act as your active genome that is to fit your controller with some new parameters. So it looks like an island model where each of these little robots are running an algorithm and exchanging material, exchanging information so as to increase performance over time. So this is not any more a stochastic optimization algorithm even though evolutionary computation still is, of course, but this becomes a distributed online learning method because, well, you are running online, you can, well, you don't care about re-initializing the position of the robots, you can really run it for a long time. You have a distributed algorithm because each of these little islands are communicating with one another so it can take time for the whole population to converge towards one particular solution and that's it. So the main difference with the classic evolutionary robotic setup is that in the classic evolutionary robotic setup you build a situation in the lab, you optimize under a specific condition and then you obtain a solution which you then deploy in the real world. While here, what you do is that you deploy your robot and then you let the algorithm learn new behaviors while it is already deployed. So you deploy then learn and that makes things quite different. So I'm going to walk you across vanilla version of the algorithm so that you really understand where the mechanics. So how do we control the robots? What we call a genome is just a set of parameters like weights of a control function which can be an artificial neural network or a linear combination of sensory inputs. So this is the first box on the left where you have a genome, so what we call a genome which are specific values in this example for something which is then going to be the controller. And how you can see here that these parameters are then used to compute the motor value, the left and right motor value of this little robot based on the sensory input which are the infrared, so proximity sensors of the robot. Here you've got four proximity sensors, two motor outputs and you combine these proximity sensors using these weights to get the motor outputs. At each time step this is what you will do and of course if you change the parameter then you will change the behavior of your robot. It's some kind of genotype to phenotype mapping. And so the thing is that the algorithm actually the evolutionary algorithm runs once in a while for a long time we just let the robot goes through time. They will act according to their current active genome which will be the parameters controlling the, while parameterizing the control function that will move through the environment possibly gather some items if it's a foraging task. This is just one example among other. And then at the end you will run the algorithm. So at each step you have to see that whenever one robot encounters another it will transmit its own genome information along with its fitness function, its performance, an assessment of its performance. And then at the end you will run this algorithm which is very simple. First you delet your current active genome. Then you lose the parameters of your control function. Then you select one of the other parameters which were received during your lifetime. Possibly using the fitness values of the different genome to force the buyers towards better performing genomes. And then you will apply some variation. So typically it will be mutation, Gaussian mutation over the parameters to get a slightly different new genome to explore in fact the vicinity of the original parameters. And then you will use this genome as a new active genome to program your control function. And then you will start again. So this is very simple. The real algorithm we put in the robots are not that much complex. Actually I had another slide which I removed where I just showed you where the algorithm, the real algorithm is just like 10 to 15 lines. So very easy to implement including in very low powerful, in very simple robots. So if we take this algorithm and let's see it another representation of the scenario of one lifetime. Here you have got the three robots that we saw before. The number in the robots are the fitness function. The fitness function is actually the number of the fitness value, sorry. And the fitness function is the number of items that you have gathered in the environment. And so this is the fitness value. And here you have the reservoir. So this is contained in each of the robot. Of course it's not centralized. And here we're going to record the other genome, the incoming genome and the values of the fitness value of each genome at the moment it was transmitted. So what you see is that your robot are moving around. They are gathering items. And at some point they will stop and they will do this. They will execute the algorithm I showed you before. So actually the blue robot here got one genome. The genome of robot red. And at this time when they met, when they exchanged genetic material, the fitness value of the red robot was one. The red one got two genome from both robots with different fitness value. The green with two because it got two items and the blue. And the green one is similar to the blue one. It got only one genome from the red robot. The interesting thing is and what actually the distributed aspect of the framework does is that there are several selection pressure. It's not as in evolutionary computation, classic evolutionary computation. When you are in zero dimension, here you've got two selection pressure. One is coming from the fitness function. That is the green robot is actually the best at foraging. And whenever it will spread its own genome, it will be for sure selected because it's better than any other one. But the red robot was not better in terms of fitness function but was better at spreading its own genome. So it's best in terms of mating. So here you can see that there are two selection pressure, one at the individual user defined fitness function level. Another one which is just related to the way the robot will move in the environment and which is not covered by a fitness function that is written by a user supervisor. So this impose some trade-off to be explored and to be done. And this is some things that we've been actually studying, of course, which I won't tell in this presentation because I want to stick in 40 minutes. So we did several experiments with this, of course. The first experiment we did was we put it in real robots. So here you have a swarm of 19 epochs robots. So the epochs robots are the one you see here. There are quite simple robots with sensor proximity sensors here, bumpers also. And here it's extended epochs actually that were developed at the Bristol Robotics Laboratory where we could travel some years ago. And we add something else also to these robots. We virtualize actually local communication. So this little circle shows the diameter of communication, the communication for these little robots here. So you can really see that it's local communication. And we also add another object, the white one here. It's not a robot, it's just a passive object. It's not useful. If you get to this object, you don't gain anything, no energy, no whatever. Nothing. But everybody sees it. Everybody sees its orientation and distance to this particular object, which we can call a landmark. And so in this particular case, the thing is that because you have several kind of selection pressure, you can even remove the selection pressure which is defined by the user-defined fitness function. So this is what we did in this experiment. There is no fitness function, no objective to be achieved. We are just studying the selection pressure due to the environment. So if you look at the, so it's a video with 19 robots, it's accelerated. And what you can see is that this landmark here, at first people, robots are ignoring it. But after some time, they will gather around this landmark. And after some time actually, but they are pretty much around it, most of the population, and we will move it to another place just to check if they are in fact interested by the position of the landmark. And the reason it does so is because when you've got a landmark, a meeting point, well, if you go to the meeting point, you will meet anyone else that is also at the meeting point. If you ignore the meeting point, then you will be anywhere in the environment. So your probability to meet some other robot is higher if you go towards one particular location, which everybody has spontaneously agreed on without any consensus. And once you're around this landmark, the thing is that if you meet, if there is a robot which is not driven by the landmark, which doesn't care about the landmark, if it goes by chance just near the landmark, it will face a family of robots with very homogeneous genotypic signature while he will still be alone spreading its own genome. So the probability is that he will be invaded by these very homogeneous genomes which are over-represented, and his genome will disappear. So it acts as an attractor, actually. So actually, we did some other experiments, so this time in simulation. So we did it with several number of robots with very the condition. We found actually the same results as with the real robots. Of course, we do it with 4,000 robots because we don't have grants which are funded enough to buy 4,000 robots. That's unfortunate, but that's life. And what we found is similar, but what you can see here, so these are 4,000 robots and we put several landmarks in the environment. So these are the same as the one you saw here. And the thing is that the robots are the same. They perceive their proximity sensors. They are driven by an artificial neural network which weights are evolved. So it's quite a small list. And they know the orientation and distance to the closest landmark. And this is where it's important. And what we see are three attractors, actually. The same as in the video with the real robots here. There is aggregation around the landmarks. But also we can see these robots. So it's not dynamic, but what you see when you see the video is that there are some robots which I've learned to just do for wall following. And this is very interesting because then the environment becomes one-dimensional. Just going in this part and some other are going in the other direction makes it very easy actually to meet many, many other robots and without any cost, just you have to, well, there is no cost but you just have to follow the wall to spread your own genome. So it's quite an efficient way. And the third one which was actually surprising when I saw this at first is that you have some kind of Voronoi frontiers which are emerging too. Which was actually unexpected. And these Voronoi frontiers are just emerging because there are some robots which by chance at first were fleeing from the landmarks. But the thing is that when you flee from several landmarks, you end up at the frontiers. And these frontiers also, except from this little point here, also a one-dimensional space in which your family of genome will be very robust and will meet with many other robots that have the same genetic signature. So the interesting with this thing is that we studied quite a lot of things. We observed quite a lot of dynamics, of evolutionary dynamics leading to behaviors which were actually shaped by the environment. So in the next step here, we also observed the interaction between this environmental selection pressure and user-defined fitness function pressure. And actually, they are working once, one against the other sometimes. And it's not really easy to balance between the two because if you want to favor the user-defined fitness function, you can end up with breaking the algorithm just because you will keep it from favoring the encounter of other robots. And then the algorithm will not work anymore. So what we also did was we studied task allocation. So in this setup, we have several robots. We have two kind of resources. And we have to choose among the two resources, actually. So we studied this in two different kind of environments. A separate environment, when you have two patch of resource. So the two patch are of different type and another one. And they are moving through time also. And one other time, where the two patches are the same position and this position will move over time. So here, we call it the separate environments, the separate patches actually. And this is collocate patches. So we call it the collocate environments. And in this setup, what we wanted to study was the ability for a whole population to perform task allocation or specialization. That is, we wanted to force that one half of the population would go on one resource, while the other half would go on the other resource. So it's a quite classic foraging setup with specialization, of course. So we have a fitness function which counts at each time step the number of energy, the amount of energy that you got. And to compute this, well, you rely on an additional gene which gives you your ability to synthesize energy for one particular resource. And we define this gene, so between minus 1 and 1. But what is important with this gene, which we call gene scale, is that, depending on the value, you can only synthesize energy from the first resource or the other resource. You cannot have a generalist. It's not possible. You must specialize. So the expected result is that you should have the population dividing in two sub-parts, two sub-populations, each specializing on one kind of resource. At the individual levels of origin tasks are mutually exclusive. But at the population level, each resource only gives enough energy for half of the population to survive. So you really want your population to be divided upon the two resources. And so what happens when, so this is an experiment with the separate environment. You've got these two patches. They are moving through time. And I think you see it on the screen. You see that the robots are moving and following the task. So they are both able to synthesize from the patch they are on and also to follow the right patch. But the thing is that it's quite different when you look at the environment where resources are co-located. What you would expect is the same kind of thing. But it's not. So here what you see is that here, so these are for the two environments, this is the number of individuals which are alive. That is, they have enough energy to keep on going. And here in this environment, you see that we're very close to the maximum. It's an experiment with 200 robots. There are 50 replicates. And this is the value of the gene scale, which you can see is actually specializing. And you really see it at the level of the population. It's a head map of the values of the gene scales of the population. And you can see at the first it's quite random, of course. And then you have two clusters for each resource. While on the co-locate environment, things are very different. You've got only half the population which is surviving. And actually, when you look at this, the gene scale has only one value. It could be the other way. It depends on the run, of course. But the thing is that it cannot succeed. It completely fails at specializing in this context. And the reason is due to the way we define our task. There is not a great benefit to forage in the resource, which is the less foraged. And because we use not a very big number of robots, like in this experiment, it's 200 robots, the thing is that if there is disequilibrium at first in the initial population, then it will be very unlikely that we will reach a balance. That will become more and more unbalanced. And there will be a bias in selection because of the small population. It will just end up with one genotypic signature in the population. And once it is done, the mutation operator is, well, there is a very low probability to have a change. Because the invasion barrier is very high, we would need more than 50% of mutants rising at the same time to go towards the other resource. So this is something that really is a problem with disequilibrium. And actually, we did some numerical simulation and more experimental simulation in robotic simulation. And what is shown is that actually, there are several things that matters. So we tried several population size. We tried several densities. So this means that we have an abstract graph where the nodes are robots. They are supposed to be abstract robots. And the arcs between nodes represent communication between the agents. And in this case, what we can see is that when the population size augments, then we are able to retain the specialization longer. The second thing is that when the density is increasing, so when you are going from a very sparse graph to a more dense graph, and not that dense actually, then it becomes too difficult so you cannot maintain specializations. So specialization occurs because of some kind of geographical separation. So here, it's just sparsity, but in the robotic simulation, actually, we implement, we model geographical separation. And the last thing is that we also made some experiments with the selection pressure applied by user-defined fitness functions that capture actually the foraging, the performance with respect to foraging. And the more artificial selection pressure you put, the worse actually the algorithm is working. So it's an interesting result because it turns out that even if we want to help the algorithm by explicitly what it should be done, that is foraging of resources, then it turns out to be counterintuitive compared to letting just the environmental selection, which actually captures the fact that if you don't get energy, it will just stop moving and stop executing the algorithm. So this is quite interesting, of course. At least we think it is. We know that embodied evolution is quite a good candidate for doing swarm robotics lifelong learning. And we have several results with respect to this, which I won't have time to discuss. But the thing is that there are some limits also. We are, because of the complexity of the interaction between the algorithm and the environment, it's quite difficult to find solutions to pinpoint what are the real problems of these algorithms. And we are more or less creating some simulation, observing at the phenotypic level what is happening. But it's difficult to say what's not working. So we end up with some kind of analyzing rather than improving the algorithm. So and we know that as we just saw, for example, specialization and some other kind of cooperation behavior, like cooperative venting, it's quite difficult to achieve. So what we have been doing recently in the last three to four years is that we took a step back and actually tried to model to find some formal model of collective decision tasks, of cooperative tasks, and tried to control the environment so that we can really pinpoint what's not working and how we can really solve this kind of problem. So this is, in fact, what we did. So in this work that I'm going to present, what we do as a methodology is that we start from evolutionary game theory. In evolutionary game theory, you know that there are some very well-defined games. We know that, we know the dynamics of these games. These have been quite extensively explored. So and they are highly used in modeling, in biology, in evolutionary biology, of course. So we take these games and then we look at the results. Of course, they sometimes do not match with what we observe when we do the same within our simulation or with our real robots. And then we try to add simulation of the coordination mechanism, that is the mechanistic aspects of interaction, of physical interaction between agents, and we try to see how much it changes actually the games that we are studying. So the stag hunt is a quite famous model. So it's the case where you've got two hunters and these two hunters have the choice to hunt either a hare, which is some kind of rabbit, or a stag, which is a larger animal, where there could be danger if you try to hunt it alone. So the payoff matrix here says that if you try to hunt a hare, you're successful and you're going to get one point as a result here. If you hunt a stag, well, if you're alone, you will just lose. Well, actually, if you hunt a stag, so if hunter one hunts a stag, you will get zero because it's too risky, because it's too dangerous, because the stag is too powerful or whatever. And the other one, well, we're still hunting the hare, we still get one just as before. And but if both hunt the stag, then you will get a higher reward. So this is quite different from the prisoner's dilemma because in this case, you've got two equilibrium. You should not deviate when you are both hunting the hare because if you deviate, the other one will still have the same gain and not you. And you should not deviate if you're hunting the stag because, okay, maybe it will cost something to the other, but the thing is that it will also cost something to you. So you have this payoff dominant equilibrium, but you should stay. And this is a risk dominant equilibrium. So these two Nash equilibrium, you should not go away from this equilibrium. As you saw, it's not a stag, it's a lion. So the thing is that when you take this numerical simulation, when you take, sorry, this game theoretical framework and you do numerical simulation or analytical simulation, there is the effect of genetic variability. That is because of, well, it's called drift selection. That is when you've got your gene, there is some probability that you will change the value of your gene. And of course, if you're alone, you will just go back to the previous stage. And if you start with both hair and dirt, the thing is that, well, it will still act as an attractor. But of course, drift selection, when you've got only one gene defining the ability to enter a hair or a stag, the probability that both individuals will mutate at the same time is quite high. And then thanks to drift selection, actually, you will end up with this kind of run. So these are numerical simulations where we have 30 runs, I think. Yeah, 30 runs. When we have 30 runs where you converge toward everybody's ending the stag, that's a solved problem. You've got some oscillation also because drift selection is not about converging to a stable state, but oscillating between several states and you look at the frequency at the time you spent in each state, in each equilibrium, and the pay-of-domain equilibrium is the one that you spend the longest time. So that's great, but if you put it in simulation, so in the setup that we are interested in, if you introduce physical interaction, maybe things will change a little. So what we did for that, so this is the same evolutionary algorithm that I showed at the very beginning. This is control setup. By doing this, actually, we forget about the mating problem. We remove the mating operator from the picture. We completely control the environment. We put two individuals, two robots, which have sensory inputs, which can also sense the type of the object they are seeing, if it's the other enter, if it's a stag, if it's a hare. So hare are green and stag are violet, purple. And we then define a pay-off matrix, which is the same as before, except that we boost the values so as to take into account the fact that they also have to travel, so it's not just one and two. And we do some experiments, so I won't go into the details, but we check that there are enough evaluations so that it's not just fitness noise, and we vary the number of prey so that we know that it's not too particular. So if you do this, the kind of results you get is this. Actually, what we saw previously just fades. It's not predictable. You end up with these individuals. So I did not explain the figures. These are the number of generations. This is the percentage of successful stag hunting. And this is the... So for all the runs, the inevitable runs, we look at what they are hunting. And so here, as you can see, well, they are all green, almost all green. So it means that all runs have the best individuals in the end which are actually hunting hare. There is no transition towards stag hunting. And for all these experiments, we start with the worst case. That is, we pre-optimize the behavior that all hunters are hare hunters. That is, they are in the risk-dominant equilibrium. So it fails. It completely fails. And that's not a good thing, of course. And the thing that you could argue is that here it's a case of mutualist cooperation that these individuals are not related. What will happen, of course, if individuals would be related? That is, we know that if there is an inclusive fitness at work, you may quite easily evolve cooperation in this kind of case. So this is what we did. It's not so great. So we take an extreme case of relatedness. It's completely artificial. Of course, we take clones. So when you hunt with a clone on yourself, there is no pairing between a different kind of individual. And still in this case, it's not so easy to evolve cooperative hunting on the greatest prey. So you could say that if you let it run longer, you've got some transition, but it really takes time. In the end, probably, they would all transition. We did some much longer run, but it really takes time. So we didn't converge all the runs to stag hunting. And in this case, what you can see is that, on the contrary, so the blue arrows are pointing the runs for which the successful stag hunting was more than 50%. And what you can see is that there are actually hunting stags failing quite a lot of time. And also, well, more or less, failing as often as they are succeeding in hunting the stag. Okay, and we did also something, but I will be very quick on this. We changed the payoff matrix to introduce some kind of recycling pathway. So it's beneficial to hunt the hare when you are two, because we wanted to force the evolution of hunting the hare just to see if the transition to the stag, which is now facilitated, would be easier to observe. And that's actually not really the case. It's even worse than with the cloning setup shown previously. But what was interesting with this experiment, with the cloning one and this one, is that we actually got a glimpse of the strategy that were used by the robots to solve the task. And what you can see is this, so of course these are robots, not animals, but they are first wandering around and once they found one another, they are turning around one another in order to hunt the different prey. And this turning is quite efficient, but also loses a lot of time and energy and sometimes fails just as it just failed now, but makes it possible to hunt the stag. So from this, there is a question, and this is the last question of my talk, is that, okay, why they do not evolve some more complex behavior, especially when we have the recycling pathway. That is, robots are supposedly different and they may be able to take roles. And of course, maybe taking roles could be interesting. Maybe they could be more efficient at hunting. So in order to do this, in order to explore this hypothesis, something which is very arbitrary, is that we try to complexify, to enable more complexity in terms of behavior. So theoretically, if you've got a neural network with enough connection and nodes, it is possible to have a universal approximator and whatever, but in practice, when we did it, well, it was quite simple behavior that we got. So even if it's theoretically possible, we forced the representation to be able to represent some things which could be forked between two behaviors. So we added a new mutation operator, which is a duplication operator, which is inspired, in fact, from gene duplication, where you just duplicate the same gene and you let both gene with the same function to deviate. Of course, it's artificial, so no biological realism here. But here we duplicate rule network. So the idea is that these one robot could either have one network or two robots, two networks, and when they have two networks, they can choose when they are cooperating, when they are hunting together to switch from one network to another. So in terms of genetic encoding, this means that you have now two networks mutated and diverged. You have this gene duplication, network duplication operator which can create two networks out of one, or when you've got two networks, just a blade, one of the two. So maximum you have two networks. And during the lifetime of the robots, during evaluation, you have this choice, so we had also several strategies. You can choose among the different networks to assume some kind of different roles, to force that different roles are possible. And we did it, so a slightly different payoff matrix, but it's still the stag ant. It retains the same property as before. And what you can see is that with this gene duplication, you have really a rise, very quick rise in the number of runs that end up with successful cooperative hunting on the larger prey. While this is the control which was the previous experiment, which grows but much, much slower. And actually if you see at what they do and if you analyze the results, you see the following. You've got a very different strategy. You've got a symmetric strategy. So gene duplication, network duplication makes it possible to break symmetry. And you've got a leader follower strategy. So of course, in nature or without the robots in another environment, it might be different. But one thing which is important in these results is not the fact that they are moving that way, it's the fact that it is at symmetrical and that there is a leader. Because if you look at the original payoff matrix, which was a coordination problem with two players. But when you have leader follower, you completely change the game. In fact, it's not a cooperative game anymore. It's a game with only one player, because it is copied by the other. So if it switch from the herring thing to stagnant thing, then it's just one switch. If the follower doesn't care about what it's hunting, it's just following the previous one. So this is about turning a cooperative game into an individual optimization game. Which is of course much simpler. So this is quite interesting because of course this was not captured by the original game theoretical setting and this is something that actually can happen if you model the physical interaction between individuals. So it works with robots. It might work in nature though I don't know. Because I'm not, well I don't know. And that's it. So that's it. So I'm going to conclude. The only really important icon message that I knew I would be late so I watched it in red. So I'm working with swarm robotics and so what we think is that if swarm robotics is to be successful, well we are in an unknown environment and we cannot predict anything. So we must also consider learning capabilities in this swarm robotics. Of course it's difficult because it must be online, because it must be distributed if we are to achieve optimization in the real world. And that's about it. I will finish by thanking the people who collaborated with me and thanking the funding which are important but less important than the people. Thank you.