 Hey folks, welcome back to the Artificial Life Advanced Class. It's t-minus one. Check this out. Potential grandchildren zero. Yeah, we're not quite there. We made a ton of progress. So that's what we're going for. The idea is we're gonna grow the thing up, get everything packed down tight enough. That's part of what we're having a problem with and then cut the diamond four ways with two kids and two left-over bits. Mostly what they're gonna be somewhere down the road. Reproduced by cutting diamonds. We're close, but we're not there. Okay, so the goals for this time was programmed diamond cutting. I'm giving myself a plus and minus. It doesn't say programmed diamond cutting that works. I was also supposed to finish the forward-to-companion of carrying the book manuscript from my dad. Actually kind of did. Have some fun. This ancestor stuff was pretty mind-twisting, but I'm kind of pleased with how it's seeming like maybe it's gonna come out. I want to spend most of the time actually today talking about little bits and pieces of that. So yeah, had some fun. Alright, timeline. So the big hole in it was this diamond cutting and then you can see we've made progress on that. I'm going sort of orange on those because they're not really working yet, but I was working on both. Trying to get the diamond to actually cut in some reasonable way. There's a big problem which is the very last step of separating the two kids, the left daughter and the right daughter. There's no real way to synchronize it because the left daughter is being controlled from the center of the left daughter, the right daughter is being controlled from the center of the right daughter and the cut is happening in the middle. Those things are many sites away from each other. They cannot happen strictly synchronized no matter how hard you try. So, which you'll see. Alright, the diamond life cycle. So back in July, this was the original plan. Start with a mother and let it grow big. This ugly in the middle was the ancestor code somehow. Move the code out of the way so that we could then make a copy of it and then do it. And this is, you know, been the plan all along and we're getting close. I cleaned up this diagram. It's a proper life cycle figure where, you know, we've got the diamond with a code in it. We move the code to the left. So that code will become the right, the left daughter, then copy it over to the right and then finally somehow cut them split them in half. Now, I actually did not move the code to the left. Instead, I made a copy of the ancestor code over to the left and then erase the code in the center because I couldn't really figure out a good way to move it. We'll see. I mean, so this ends up meaning that the code gets copied twice for every reproduction, even though it's not strictly necessary. I'm really caring a lot less about efficiency these days. You know, it's funny. You care about efficiency if you're sitting and paying attention to something. But if you want, just walk away and come back tomorrow and have stuff happen, like your garden has grown. What you want is not efficiency, but robustness. And that's what we're doing here. Okay, the ancestor code loop. You get that picture of going around and around the mother, the left or the right daughter, and then there's two of them. And the code follows that exact pattern. This is the current ancestor code. It's 16 instructions long, which is ridiculously tiny compared to like the von Neumann replicator, which was like. But again, this is a completely different spirit. Each of these, and rather than thinking about this is a tiny little instruction like add one to a register. Each of these instructions is essentially a process that's capable of doing a whole bunch of stuff until something that goes outside of its expertise comes up and then it moves on to the next one. So these are actually just the names of the variables that I got to do with these are configured things. But the point is, is that all of these instructions in the first group, they run in the mother in the center of the thing. These here run in the left order and these at the end of here run in the right order. And then this last one, this weight cut, the left rotor and the right daughter do it again. They both they put together as together as possible. They arrive at the final waiting point for the cut to come through and then theoretically they will zoom on in back to the top and become mothers on their own. At least that's the plan. You can take this code and lay it out on top of the life cycle loop. And it doesn't matter what all these things really are. Those are just the 16 instructions. And they go in perfect order and that's not chance that was designed that way. So there's this concept called auto polices. It means sort of self production or self assembly self organization. And there's a bunch of really, I think, kind of cool examples of it in this ancestor code as well. So for example, this SL instruction up here, it stands for send loop, like it's it's both a loop in the sense that it sends codons one at a time, but it's also a loop in the sense that it sends the entire loop of program code, which is arranged in a circle. And it sends it down to the left daughter and the left daughter has a send loop in it as well that sends it to the right daughter and so on. Now there's a bit of a trick here because the actual, well, let me let me go on and then circle back to this on the next slide. So, you know, okay, that's great computers sending software to each other. Sure, we understand that, but it's more complicated than that, right, because we have to essentially create the hardware. We have to create the receiver that's going to get the code. And that's what this is about. These these BCs that again doesn't really matter what it is. These are the things that build the construction arm. And the last step in that construction arm going across the thing is to create a diamond sequencer endpoint far away at the end of the construction arm. Looking back with its I'm ready to execute whatever you throw at me what it so it's just there it'll take one instruction and that one instruction has to be enough to get things going. So what we need to do is number one, we need to build the daughter we have to build the processor build the hardware and then we have to send software down and that's what this trick is all about. The first instruction through the pipe is an RL which is a receive loop. So the send loop is going to send codons down but only it's only going to work because the first instruction that we sent to this brand new processor was learn how to be a receive loop and the same thing happens down here. Here comes a new endpoint being created for their right daughter. And here comes the RL instruction the send loop sends the RL. There's this problem that after the mother sends the entire loop, there's more to do the mother in fact is going to erase it herself once she gets confirmation back from the left daughter that it got everything. So that's what these two instructions do. It's a wait and a kill loop doesn't matter the details. But the point is, is that we have to not send them to the left daughter because the left daughter needs to see the receive loop first, but we need to have these happen afterwards. In fact, this was a lot of trouble. The send loop has a little argument saying how many instructions do you need to do after you copy the whole loop. And it takes these two and it puts them in a whole nother loop on the side, expressly waiting until the whole thing has been copied back around to it. And then it does that final little post copy. And that's what made this whole thing work after several things did not work. So you can see it there there's the KL and WT those are a little two instruction buffer that the diamond sequencer is going to end up running after this send loop over here says we're done. Okay, let's look at some demos. Okay. This looks like a picture but it's actually live. Certainly one of the things that I did. I've started using the MFM as ability to take snapshots of machine states and load them back in. And you know this is one thing that we can never do on the T2 tile because there's no synchronization point for all of them, even if we had a place to put all the data, but we can do it here. So here's just the startup. And you know here's the loader and here's an empty code on we haven't even loaded anything yet but we don't have to sit and wait for it because I've recorded a whole bunch of other ones. So here we are after the arm has been built over to the left daughter and but the first codon hasn't gone through it yet not going to run this one. There we are with a closer look and there's the the RL that's the received just about to arrive maybe we can catch it happening actually so the diamond needs to grow one level bigger and we got it. Okay. The funny thing is when you reload one of these things and then say run it's not replaying something. It's living it again, you know the random numbers might have worked out differently, but in this case. Okay, and now it's stashing away the BC's those are the things that are going to allow to construct the next arm going downstream, and so on. All right, let's take a look at a couple of others and then try to wrap up and not go long. Okay, we got a bunch of these things that I'm going to skip over here. The black and white that is the, the left daughter is now killing the transfer cable, which both because it's not needed anymore. And because it's a signal to the mother that the left daughter is now fully booted and doing all its business and the mother business which is in fact just checking out in this particular case right and there it started it's deleting its own copy of the loop which scared me at first when I was implementing this because like now we've only got one but you know that's what we're signing up for. We're making copies of these things we have to trust it and if it's not going to come out being right we're going to have evolution. So, okay, and the mother cleaned up completely including erasing the diamond sequencer that means the endpoint is gone there's no more ability to execute instructions at that spot. All right, let's jump ahead to the last part of it. Okay, so now the left daughter is growing the second construction arm all the way over to where the right daughters do this is about the slowest part of the whole thing. These construction arms get slower and slower because it's sending messages all the way around trips saying did you get it done I got it done all right now do this did you get it done and so forth because unlike with traditional ones where you know exactly what's going to happen. Let's move on in this case you have to wait okay so there it is now the daughters is just about to be deployed the right daughter and here's here comes the. This is the receive loop that matches the receive loop that the right hand order already used and that's how the receive loop knows it's done the receive loop comes twice and it tracks at the first time and then matches at the second time. And okay. Last little bit let's jump ahead here. DX that's the deploy the diamond cutter and. All right, there it is there it's right in the middle. It looks weird because I'm displaying the circles but it looks better when I'm not. And what the diamond cutter does is it climbs up the gradient to find the root of the thing and when it's at the root, it makes the whole diamond stabilize it freezes it so that there's the best chance of having its cut successfully. And there it goes it sends those two things out and it's a complete mess and partly it's just because the the the four way cut is sliced through the program loop, but it's also because there's just absolutely bugs in the process of trying to make a diamond shrink. Most of the diamond code was assuming that they only grew funny how that works. And all right, and oh geez we're out of time. Okay, so that is it. Next time is the last time it's going to be there's only one goal, which is get the whole thing done. You can see how we got children but not grandchildren and that's why the goal is all in this all the way along. Have a happy New Year. I hope to see you next time.