Computational General Relativity: Live with Jonathan Gorard

Okay, hopefully we're live. So. Hello. Hi everyone. Thanks for joining us. So today I'm Jonathan Gorard, and today I'm going to be giving a kind of brief overview of some new functionality for doing computational general relativity in the Wolfram language. So that includes both kind of analytical general relativity, so doing analytical computation, tensor computations over, you know, space times with closed form metrics, but also numerical general relativity, so doing kind of numerical simulations of space times to which, for which, to the best of our knowledge, there does not exist any closed form solution like, so things like compact binary inspirals, black hole mergers, certain kinds of gravitational collapse, things like that. So this is new functionality that is partially deployed through the Wolfram Function repository and partially deployed as a standalone packlet. I'll talk a little bit in a moment about how exactly you can start to use some of this stuff. But so it's a framework that's based on that's really trying to reflect one of the kind of core design principles of the Wolfram language, one of the core philosophies of the Wolfram language. So namely, wherever possible, a kind of lack of distinction between symbolics and numerics, or between, if you like continuous mathematics and discrete mathematics. So in the Wolfram language, typically if you use a function like, I don't know, eigenvalues, you can put in a purely symbolic matrix, or you can put in a purely numerical matrix and the functionality will work pretty much the same. The internal algorithms are completely different to handle those two cases, but you as an end user shouldn't have to care. And so the Wolfram language is kind of designed in a way that lets you chop and change between sort of symbolic and numerical computations to the greatest extent possible. And the general relativity framework that we're developing is essentially designed to reflect the same core principle, so that fundamentally it doesn't care whether you're doing analytical computations over some smooth closed form Riemannian manifold, or you're doing numerical computations over some kind of coarse discrete approximation to a continuous space time represented in terms of hypergraphs and causal graphs. And that's actually a fairly non trivial thing to do. And in fact, to a large extent it's only made possible thanks to some fairly recent research innovations that have been made via the Wolfram physics project. And maybe towards the end, if people are interested, I'll talk a little bit about what the precedence to these ideas and this functionality actually was, and a little bit about the history of the underlying research. Okay, so this is ostensibly a live Stream. So although there will be a kind of structured parts of the talk, you guys, we've also tried to schedule in sort of sufficient time for questions and discussion if there are things that. So I'll be vaguely monitoring the chat and Sabrina and Rachel and people are here to sort of, to help, to help manage some of that, as usual. And so I'll be kind of vaguely keeping an eye on what you guys are saying. So if there, if there are things that you particularly want me to focus on, things you, things that I said that you found interesting, questions that you have, things I said that you thought didn't make any sense or, you know, things you're confused about or whatever. Please post those in chat. I may not interrupt the, you know, the main proceedings, but we'll definitely try to get to all of that towards the end. Okay, so with that, I should probably share my screen. Let me make sure I share the right screen and make sure that I've got the right notebook open and hopefully someone can tell me if I've done something horrifyingly wrong. But hopefully you should, you should see a notebook that says computational general Relativity in the Wolfram language. So first things first is what, you know, the part of the idea here is that all of the stuff I'm going to be demoing here today, you should be able to do yourself in your own, you know, in any Mathematica kernel or Wolfram desktop instance or even, you know, within the Wolfram cloud or the Wolfram programming lab or whatever. So the codename, the internal code name for this, for this General relativity framework is Gravitas. And by this point, a lot of the core functionality of Gravitas is now fully documented and has been exposed via the Wolfram function repository. So if you take any one of these functions like say, ADM decomposition, and that's conveniently opened in the wrong browser. But if I take this over here, okay, so you can see, ok, so all these core functions are documented like this. You've got specifications of syntax, there's a bunch of sort of internal implementation details of the underlying mathematical formalism. So for the particular case of the ADM decomposition, we have details of like what, what gauge conditions do we support, how are we doing the canonical decomposition of the metric, what assumptions do we make about metric signature, and so on. Here's for instance, a list of some of our inbuilt. A lot of these functions have inbuilt libraries of things like known space time geometries or known stress energy distributions and so on. So this is some documentation about some of the inbuilt metrics that we support. Here's a list of the properties of that function. So here are. Over here we've got a bunch of the slicing conditions for the lapse function of the decomposition. Here are a bunch of the coordinate conditions for the shift vector of the decomposition, et cetera. And then of course, as with any Wolfram function repository documentation, we have plenty documentation page, we have plenty of examples trying to show the complete scope of this particular function. So several of our core functions have been documented and are exposed in this way. And so if you want to use any of them, you should just be able to call Resource function and then the name like Metric Tensor. And you know, if I say Metric Tensor Schwarzschild, then without having to download anything, without having to install anything, your Wolfram desktop kernel should just pull in that function and you'll be able to run that directly within your notebook. So here we just managed to produce a symbolic representation of the Schwarzschild metric, and we'll dig into a little bit more about all of that later. And one particular one that I want to highlight, by the way, just because it has probably the most aesthetically appealing documentation page, is discrete hypersurface decomposition. This is the thing that produces many of the kind of cool visualizations that those of you who've been following some of the papers that have been coming out of the Wolfram Physics project recently. It was this function and its various descendants that were used to produce a lot of those pictures. So these are. These are kind of graph representations of space, like hypersurfaces, produced through numerical evolution of some initial space spatial metric. And again, I'll walk you through in more detail what exactly these means and what exactly these mean and how you can produce pictures like this yourself. However, an important thing to note is that this is only a. As I say, this is really only a small part of the core functionality of Gravitas, and there's a lot more functionality that has not yet been fully documented or is not yet fully exposed to the Wolfram function repository, either because we just haven't got around down to documenting it yet, or because it's still actively under development. But if you want to use that stuff, which I heartily recommend you to do, then you can download, you can always download a kind of a the latest snapshot of the Gravitas build by going to GitHub.com jonathangarad Gravitas that will take you to this GitHub repository. You'll see that internally this is just a large collection of Wolfram language package files. If you download all of these, run all of them, then you should be able to reproduce all of the examples that I'm going to be showing you here today. So the examples that I'm going to be demoing will be a mixture of functions that are currently exposed to the function repository and functions that have only been exposed so far through the GitHub repository. Of course, eventually we would like to have all of them fully exposed through wfr, but this is a fairly large framework and it's still under active development. I mean, right now it's about, I think, well, at least last time I checked, which was a few weeks ago, it was about 25,000 lines of symbolic Wolfram language code. And it's constantly growing and we currently only support a small fraction of the things that I would eventually like us to be able to support. Okay, so before I show some examples, let me just first explain what is this framework, what is it meant to do, why does it exist, why did we bother to build it, et cetera. So you may know already that if you want to do numerical general relativity, there are already plenty of frameworks out there. There's the open source Einstein toolkit as part of that, which is the cactus framework. There are things that have been built on top of cactus like the Whiskey code and so on. And there are also open source libraries like GR Chombo. And all of these things allow you to effectively solve initial value formulations of the Einstein field equations and do numerical evolutions of space times involving say, binary black hole systems or whatever. So you might think something like gravitas is not really, not really required. But one thing to know about the workflow of these things is that, you know, typically, okay, so if you want to build a numerical general relativity code, very often the hyperbolic partial differential equations that you're solving have many tens or hundreds or even thousands of terms in them. And you know, it used to be that people would kind of code all of those in by hand in some low level language like C or C. But of course that became that very quickly becomes essentially intractable and you introduce all kinds of bugs. And so these days the state of the Artist use automatic code generation. So typically what you do is you input the equations you want to solve in some kind of high level Einstein tensor notation form, say in the Wolfram language, and then you use a framework like Crank that then takes that abstract representation of the equations and goes and automatically synthesizes a bunch of C code that you can then plug into a framework like Cactus or Whiskey. Then you run that numerical simulation that produces some data files. Then you take those data files and you plug those into another piece of software which is responsible for analyzing the data, visualizing the space like hypersurfaces, detecting event horizons, extracting gravitational wave data, whatever it is that you want to do. So you end up having to kind of stitch together, in many cases, maybe four or five quite complicated pieces of code if you want to do even a fairly basic numerical GR simulation. And very often this is kind of beyond the scope of what the average user is really prepared to do. And so one of the core features of one of the core design principles of Gravitas is that what we're trying to do is have a general relativity framework where you can do all of that stuff. You can define the initial equations, you can define the metric splitting, you can do all the coordinate conditions, gauge conditions, all that stuff, define the initial space like hypersurface, run the simulation with all the fancy background code synthesis and automatic optimization and so on, get the results back, analyze the results, visualize them, extract your gravitational wave profiles, etc. All without exiting your notebook. You should be able to do all of those things from within a single notebook. That's one of the big design features. Okay, Another question you might have is, well, you know, there are already lots of frameworks out there for doing computational kind of tensor calculus of the kind that's, that's relevant for general relativity. So in the case of the Wolfram language, there are things like Exact, which is a very general, very powerful sort of tensor calculus framework that is mostly written in kind of abstract index, that mostly allows you to manipulate tensor equations in kind of abstract index form. But there are specific libraries in Exact, like specifically xcoba, that also allow you to do kind of coordinate specific component computations in a fairly general way as well. And so you might say, well, you know, why bother building something like, is that something like Gravitas? Have all these tensor calculus libraries already exist? Well, again, another point is that we're not really trying to replace these things. I mean, if you want to do general purpose tensor calculus, you know, go use exact, you know, the Wolfram languages. General relativity framework is not going to replace any of that. But the point is, what we're trying to do is we have support for only the kind of the particular kinds of tensor calculus operations that are relevant for doing computational general relativity. And the reason we've re implemented that is, as I say, one of the design features of Gravitas is that we're trying to set things up in a way that doesn't care whether the space time, the underlying space time you're dealing with is continuous or discrete. And so we need to have representations of things like affine connections and curvature tensors and so on that work equally well on smooth Romanian or pseudo Riemannian manifolds and on coarse hypergraphs and causal graphs. And that necessarily, inevitably requires a certain amount of reimplementation of kind of core functionality. So we're not trying to compete with any kind of general purpose tensor calculus framework, but nevertheless, we do have inbuilt tensor calculus functionality for at least doing the basic things right. Covariant derivatives, covariate integrals, index contractions, index manipulation, all that sort of basic stuff. But again, just like with many functions of the Wolfram language, we tried to do that in a way that is maximally automated so that you as the end user, you know, you don't have to worry about details of index juggling or calculating Christoffel symbols or whatever, unless you absolutely want to. We try to handle all of that behind the scenes wherever possible. As I say, this is really only possible to a great extent because of, because of functionality and algorithms and scientific ideas that have arisen from the, from the physics project. And again, I won't get into that now because I've already yakked for too long. But maybe towards the end, if people are interested, we could talk a little bit about the sort of research background of this. Let me also just show some nice pictures. I'll try and reproduce at least some of some things like this in the course of this talk. But these are fairly high resolution or relatively high resolution simulations that take a little bit longer to run. But here are examples of things like here's a collision of two Schwarzschild black holes, or I guess more generally of any compact binary system described by the Schwarzschild metric. Here's an example of a gravitational collapse of an idealized scalar field down to a Schwarzschild black hole. And so these are all numerical simulations over hypergraphs that have been produced using this functionality. And again, one thing I want to try to convey today is how you can go about reproducing things like this yourself. So, ok, let's start with the beginning. So the basic. One of the, you know, arguably the basic object in this general relativity framework is a metric tensor. So if we, if we just call metric tensor with no arguments, you'll see a list of inbuilt metric Tensors that we support. So the Gravitas framework has a library that right now is still a little bit small, but we're trying to actively grow it. But it contains a library of prepackaged space, time geometries, metric tensors, and things, as well as stress energy distributions that you can put on top of those space times and coordinate conditions that you can apply to them. So here's a list of at least the basic metric tensors that we support right now. So if we take one of these, like, I mean up here, I took the Schwarzschild metric, let's use that in this example. So if I say properties, we can see all the various things that we can do with that metric tensor. So perhaps the most basic thing we can do is just display it as a matrix. So by default we have our metric tensor in covariant form. So covariant Q. This is effectively telling us that both of its indices are currently lowered. So if I say symbol, you can see we've got G lower mu nu. If I took this thing and instead I said false, false, this would represent the. This would give us the metric tensor in contravariant form. And so you can now see the mu new indices have gone as upper indices, contravariant Q, that would now return true. And of course, if I said like true, false or something, I would get something in mixed index form which if I reduced it will just reduce to the identity matrix. Because it's. Because this is a metric tensor. So I'll talk a little bit about, more about index juggling in just a moment, but I wanted to show that, show that first of all. So we're starting off with a covariant. So we're representing this metric tensor as a covariant matrix, that is a matrix in which all components transform covariantly under arbitrary transformations of coordinates. We could also choose to represent this, say in a line element form. So here you can see. So this is our space, time, line element with respect to the coordinates r, t, theta and phi. So if I say coordinates, you can see here's the default choice of coordinates for the Schwarzschild metric. If I say coordinate one forms, you can see here's the list of differential one forms that are being used in this representation of the line element. What else could we do? We could do something like. So the line element effectively is the thing that allows us to measure distances. We could also say something like volume form. And this will give us a representation of the function that allows us to Measure volumes. If I say reduced volume form, though, you'll notice this will eventually just. This effectively just reduces to the Minkowski in form of the, of the volume element. This is represent. This is effectively a byproduct of the fact that the Schwarzschild metric is Ricci flat. And we'll get onto that in a minute. But okay, so what else could we do with something like this? Or what else is worth saying? Okay, so maybe it's worth just explaining a little bit about the summary box. So you can see here we've got a list of the spacetime coordinates we're using. We can see that our metric tensor is symmetric. All metric tensors by default are symmetric, although in principle do have support for non symmetric metrics. And so we can support things like Einstein, Cartine gravity, non zero spin tensors, torsion metrics, contortion tensors, all that kind of stuff. Maybe if we have time, I'll get onto some of that a bit later, but. Okay, hang on, sorry, I've got a message saying can we increase our notebook view from 100% to 125%? Ah, yes, sorry, sorry, sorry. Yes, try that. Maybe that's a little bit better. Okay, yes, please, if anything's not directly visible. Yeah, just let me know. Okay, so. Right, what was I saying? Yes. Okay, so if we now take this thing, what else can we do? So we looked at the line element, we looked at volume form. We can. Okay, sorry, I was walking you through the summary box. So you can see here it says signature indeterminate. So what that means is that the framework is not yet readily able to tell whether this metric tensor corresponds to a Romanian or a pseudo Riemannian or Lorentzian metric. And the reason for that is because it's obviously represented in terms of these symbolic coordinates and it doesn't know yet what the restrictions on those coordinate values are. If we gave it something like say the Minkowski metric, metric tensor, Minkowski, then it would, then it knows that the signature of this is Lorentzian because it can compute, it can directly compute its eigenvalues. Or if I said, if I take the Euclidean metric, the three dimensional Euclidean metric, it's going to know that its signature is Romanian. But in the case of Schwarzschild it can't know that. But we can always ask. So I mean, if we say Lorentzian Q, it will say indeterminate, but we can always ask something like Lorentzian conditions, and it will return us a list of the minimal conditions that are on the space Time coordinates necessary to guarantee that the Schwarzschild metric is, or the underlying manifold has Lorentzian signature. Equivalently, we could say something like Riemannian conditions and it would give us correspondingly the minimal set of coordinate conditions necessary to guarantee that the metric is Riemannian. And so you see, it's exactly the same as for the Lorentzian case, except that this inequality sign is the other way around. So really all it's doing is it's figuring out what conditions would need to be true in order for the eigenvalues to be all positive or all negative or one negative and the rest positive or what have you. Other things. I mean there are plenty of things we can do with metric tensors. We can take say, you know, we could say something like, let's, let's take an example. What would be a good thing to do, I don't know, timelike Q or something. And so this will return a pure function that if we take this pure function we apply it to any space time vector, it will return a Boolean. So that tells us effectively whether you know, whether that vector is a time like vector. Or you know, we can have corresponding functions that tell us whether it's a space like vector or a light like vector. We can say something like length pure function and it will synthesize a function which again we apply that to a spacetime vector and it will tell us the length of that spacetime vector. Within the Minkowski. Sorry, within the Schwarzschild metric I could say angle pure function and it will do the same thing, except this time this is now a two argument pure function. You can see there are two slots, hash one and hash two. So we give it two space time vectors and it will compute the angle between them within the Schwarzschild geometry and so on. So we can do a bunch of kind of automated Wolfram language code generation. That said, you know, so that if you request back a piece of synthesized symbolic, a symbolic Wolfram language code that allows you to compute these various things. So if we change this to something a bit more complicated like say the Kerr metric, ok, so with the Kerr metric by show its matrix representation. So now you can see it depends not just on this mass parameter M, but also on this kind of symbolic angular momentum type parameter J. So I should clarify for those of you who don't know, you know, the Schwarzschild metric kind of broadly represents a sort of static non rotating, spherically symmetric body like a, like a non rotating black hole. The Kerr metric represents a spinning Black hole with, with, with some symbol momentum. But we can do exactly the same things. We can say line element, we get a slightly more complicated thing, or timelike Q or length, pure function, angle pure function. So we can make these kind of as complicated as we like and Gravitas can still handle those. So here I'm just using inbuilt metrics. But it's important to note, of course, that we can just take, you know, we could put any, any, any symbolic metric that we liked in here. We could just give it any, any matrix. I don't know why I've opted to just type in a random matrix by hand rather than generating one symbolically, but so be it. That's what I've done. Ok, so then we get some matrix and in this particular. Oh, I wasn't even planning for that to be the case, but apparently this is. I accidentally input a Lorentzian metric, so that's nice. Anyway, that's probably enough about metric tensor for now. So I just wanted to give you an indication because if you like, the core design of metric tensor tells you a lot about the core design of a bunch of the other functionality that's within the framework, because essentially all the other stuff within the Gravitas framework is really just a metric tensor plus some additional wrapping. So there are various things that we can immediately do with a metric tensor. So we could, for instance, we could compute something like the Ricci tensor. So let's say just, ok, I'm going to do this, even though I know it's going to be super boring. So if I say Ricci tensor metric, ok, so this will compute a symbolic Ricci tensor. So if I just say matrix representation of this, we'll get some, some complicated thing. But of course the Schwarzschild metric is Ricci flat. So we know that if I say reduced matrix representation, this is just going to reduce to the zero matrix. So when I say that, when I input reduced in one of these properties, what that's doing is it's taking some symbolic, in this case, some symbolic tensor object and it's effectively modding out by all, by all known tensor equivalences. So because Gravitas has a kind of inbuilt tensor algebra and tensor calculus framework, like it's able to keep track of all the kind of known equivalences between tensor, between abstract tensor expressions that you kind of accumulate as you do successively more complicated calculations. So in this particular case it managed to reduce that thing down to just a zero matrix. And we can confirm that by saying Ricci Flat Q and it will say true, Right? So it's telling us that this particular metric tensor corresponds to a Ricci flat space time. But if I used a different metric tensor, like say the FLRW metric. So the FLRW metric, of course, the Friedman, Lemaitre, Robertson Walker metric being the metric for a homogeneous and isotropic sort of uniformly expanding or uniformly contracting universe with some scale factor A and some discrete curvature K. If I take this and I compute its Ricci tensor, then even in reduced form, this thing is generically non zero. So if I now say Ricci flat Q, it will say false. Of course, I can always say Ricci flat conditions, and it will tell me the list of conditions that would need to be satisfied by our curvature parameter and sorry, by our scale factor and our curvature parameter in order for the FLRW to be a Ricci flat solution. Similarly, I compute the Ricci scalar. I forget actually what that's called. If it's scalar curvature or Ricci scaler, I think it's Ricci scalar. Yes, it is. So if I say Ricci scalar or reduced Ricci scalar for the FLRW metric, I could equivalently say something like vanishing Ricci scalar Q. So this is telling us the Ricci scalar does not vanish for the FLRW metric generically, but there is a condition in which it does vanish, and that condition is this. So the Ricci scalar, by the way, is what happens if you take the Ricci tensor, which is itself a contraction of the Riemann tensor, the full curvature tensor, and then you can track the Riemann tensor along its first and third indices and then you contract the Ricci tensor, so you just effectively take a trace and that gives you the Ricci scalar. So if we wanted to, we could see in detail exactly how this thing was computed, because we can. We have all the pieces necessary to do that within the framework. So if I say Christoffel symbols metric, so this will compute the Christoffel symbols for, in this case the FLRW metric. So if I say so this is. Now this is a rank 3 object. It's not actually a tensor, it's a. It's more like a sort of, it's a higher dimensional array that sort of acts a bit like a tensor under linear coordinate transformations, but not on the general diffeomorphism transformations. But anyway, so this, these Christoffel symbols represent the components of the affine connection for this, for the FLRW metric. So if you like intuitively what they're telling you is how do the basis vectors change as they move from point to point along a manifold that satisfies the FLRW metric? And so this has effectively been computed by calculating certain partial derivatives of the metric tensor. By the way, another thing to note is, and this will become important for the numerical computations I'm going to do later, by default, Gravitas will try to evaluate all of these complicated partial derivatives and so on analytically wherever it can. There may be cases where it can't do that. So in those particular cases, if we say, sorry, why did I call this? This was. Why did I call this metric? This is ridiculous. Sorry, yeah, let's call that Christoffel symbols. That's a good name. So if I now say Christoffel symbols, if I, instead of saying tensor representation, or for that matter reduce tensor representation, which will again try and simplify this expression wherever it can by applying tensor, by applying possible algebraical tensor equivalences, I can instead say symbolic tensor representation. And in that case it will return us a purely symbolic form where you can see we've got all of these symbolic inactivated partial derivative operators with respect to each of the space time coordinates. So this is just returning us purely symbolically, what form will the Christoffel symbol take for this particular metric tensor? And so in cases where, for instance, these partial derivatives are actually not analytically tractable, then we can still compute something in finite time by just saying, give me the symbolic representation. And then the point is, this is then something which we can potentially numerically approximate using methods like ndsolve. And we'll get onto that in a little while. Oh, actually, one thing that's worth saying now that we've got. So this Christoffel symbol thing is a, is obviously a higher rank object. So if I take SO in particular, we can compute its index contractions. So by default, if I say symbol, you'll see that the Christoffel symbol is by default computed with the first index raised and the last two indices lowered. Although of course we can change that in a moment, as I'll show you. So that means if I say index contractions, let's do reduced index contractions. Ok, so that will simplify it a little bit. So you can see with these three indices configured in that way, there are two possible contractions of the Christoffel symbols. We can contract along the first index, sorry, the first and second indices. So you can see there's a repeated sigma here. So we're using effectively Einstein's summation convention. So we get this, what would it be? This is a covector object. Or we can contract between the first and third indices. So we get. So this is sigma, sigma, nu, this is sigma mu, sigma. And we get this different covector object, although actually in this particular case not very different. It's exactly the same. Nevermind, this would not be true if we had a more general kind of connection that was not necessarily symmetric. But okay, so, but if we now took this thing. So if I take this Christoffel symbols object and I raise or lower some of its indices. So if I said Christoffel symbol, let's take the old thing, say Christoffel symbols two is that. And then I'm going to say let's do true, true, true. So these Boolean flags are specifying whether a given index is covariant or contravariant, that is whether it's lowered or raised. So true, true, true means that all of these things are covariant. You can see this is now type covariant. So if I say Christoffel symbols 2 symbol it will be that. But if I now try and try and take index contractions, it's going to return an empty association because there's nothing to contract. We can't contract two covariant indices. We can only contract covariance and a contravariant index. So if I said false, true, true, then that would take us back to the case we had before. But I could equally say I don't know true, no, what should I do? Let's do false, false, true, that's a slightly different case. And now we get a more complicated thing. But okay, so we get a different set of index contractions now. So now we're contracting, you know, sigma mu sigma versus rho sigma sigma, and we get, we get a different. So in this case that those are going to be. Whereas before those we contracted the thing, we got covectors. Now we're going to be contracting this thing and we're going to get ordinary vectors, right? Because now the free index is the one that's raised. So I'm just. The only reason I'm showing you this is to show how sort of symbolic, how these sort of symbolic tensor calculus operations are handled within the general relativity framework. But as I say, kind of the whole point of this framework is that for the most part you don't really need to worry about this. I mean, we've tried to design everything in a sufficiently high level way that all the kind of standard things you would want to do in General relativity, you can do without having to worry about the internal details of index raising index loads and all that kind of nasty stuff. So although in particular, okay, so if we took, so this was the Ricci tensor, if we recall, this is the Ricci tensor for the FLRW metric. If we took this, let's just check. Yeah, that is still working. We could take this particular thing, we could say something like covariant derivatives and actually let's do reduced covariant derivatives to try and get them in their simplest form. And so here we'll get back an association of covariant derivatives of the Ricci tensor. So you can see this is the covariant derivative with respect to time of RTT is this. And so, so we get this complete association of all the, all the different covariant derivatives that can be computed of this particular tensor object. And you can see that a lot of them are zero because this happens to be a diagonal matrix. But and of course, okay, if we took, so this is with the Ricci tensor being in covariant form. If we did say true false, so we had it in mixed index form, we get a slightly different thing. And if I now say that you can see we get a different association with different values of the covariant derivatives because we've added and subtracted a different collection of Christoffel symbols and we've and done all that kind of, all the sort of nasty raising and lowering operations that you would need to do. So again, the point is the gravitas kind of handles all this for you. You don't need to worry about when are you adding a Christopher symbol, when you're subtracting one, or any of that stuff. And moreover, for the most part, you don't even need to be using functions like reduced covariant derivatives because for all the kinds of things that you would ordinarily want to take covariant derivatives, like constructing Einstein equations or doing numeric solutions, you know, the framework will handle all of that for you. So it's really only for sort of certain power user types we expect to be that we expect them to be using these functions like, like, you know, for computing covariance derivatives and so on. Okay, so. Oh, right, I was showing you how, you know, how we would go about computing the Ricci tensor from first principles. So once we've computed the Christoffel symbols, we can then take derivatives of those and we obtain the Riemann tensor. So if I say resource function Riemann tensor of Our original metric, the DFLRW metric, let's just call that Riemann, sorry, Riemann equals that. I say tensor representation. So this is now going to be. This is an even higher rank object. This is a rank 4 tensor that we've computed by evaluating certain partial derivatives of the Christoffel symbols for the, for the FLRW metric. So this is what the Riemann tensor looks like for flrw. And so again, we can do all the same things that I showed for the things like the Christoffel signals. We can compute its index contractions. You know, in this case we're going to get more index contractions. We've got three now because it's a rank four tensor. And if we say had, if we had this in mixed index form like this, so we had two. Oh, this is. Raising and lowering those indices is probably resulting in something overly complicated. Okay, there we go. So we get a slightly different thing. If I now say Riemann index contractions, okay, now we get four index contractions. So we've got two raised indices, two lowered indices, and we get these, these things which are, each one of these is effectively a matrix that we, you know, a rank two matrix that we've obtained by, by contract by doing index contractions of this rank 4 tensor. And in the same way we could, just as we saw for the re for the Ricci tensor and things we could say, we could take any of the, in any tensor expression, with the exception of things, with the exception of obviously silly things like the metric tensor, but any tensor expression represented in the framework, you can do index contractions, you can take traces, you can take covariant derivatives, you can do all the kind of ordinary things you would expect to do within, in the context of tensor calculus. And it will handle all that stuff for you behind the scenes, wherever that makes sense. So then once we've got the Riemann tensor by taking its index contraction between the first and third indices, with the first index raised and the third index lowered, then we obtain the. That allows us to derive the Ricci tensor, which is of course the thing that then appears in the Einstein field equations. The significance of the Ricci tensor, by the way, being that it's essentially the thing that determines the volumes of space time cones and the Ricci scalar, the thing that determines the volumes of things like spatial balls relative to the corresponding volumes that they would have been had the space been flat. So if we take, say this Ricci tensor for flrw, and I say something like volume form expansion, what it will return is effectively a Taylor expansion of the volume of a space time cone represented in terms of the volume of the corresponding cone mu. So V is the volume of the spacetime cone in the FLRW geometry. Mu is the volume of that spacetime cone in the corresponding Minkowski geometry. And so this Taylor expansion is effectively the thing that's defining the discrepancy. And this Taylor expansion is represented in terms of terms that have come from the Ricci curvature tensor. Equivalently, if I say something like scalar volume expansion, this will give me the corresponding Taylor expansion for the case of. So here we're not talking about a directed space time cone, we're talking about a sort of undirected spatial ball. So in this case, so v epsilon is going to be the volume of a ball of radius epsilon in the FLRW space time mu epsilon is going to be the volume of a ball of radius epsilon in the corresponding Minkowski spacetime. And again, this Taylor expansion is going to give us the discrepancy between the two represented in terms of the Ricci scalar. So again, the framework allows us to compute all of this stuff if we wanted to. I mean, so for instance, I know that if I say curvature singularities, So you're right. Okay, so there are certain coordinate values where we know that the FLRW metric is going to become the Ricci tensor for the FLRW metric is going to become singular. Incidentally, this is in contrast to, for instance, if we take, if I say Schwarzschild and I say metric singularities, you know, so there are certain coordinate values, so r equals 0, that's the kind of physical singularity r equals 2 m, that's the coordinate singularity at the event horizon. But of course, because the Schwarzschild metric is Ricci flat, those things don't persist. If I take, if I compute its Ricci tensor and I try and find its curvature singularities, those will not show up as curvature singularities. They will show up as curvature singularities for the Riemann tensor, but they will not show up as curvature singularities for the Ricci tensor. And in particular, this specific thing will show up as a singularity for the Kretschmann scalar. So if I take the Riemann tensor and I. So unlike with the Ricci tensor, where there's only one sort of scalar quantity curvature invariant that we can compute from the Ricci tensor, there are three curvature invariants that we can compute from the Riemann tensor. I've spelled Kretschmann wrong. I think that's how you spell it. So I can compute the Kretchman scalar for the. This is me computing the Kretchman scale for the Schwarzschild metric. So the Kretschman scalar, that's the thing that effectively quantifies, you know, because there's no Ricci curvature, essentially it's all Weighl curvature. The Kretschman scalar is the thing that effectively quantifies the spacetime curvature for a black hole spacetime like the Schwarzschild spacetime time. Okay, that's not its simplest form. If I said reduced Kretschmann scalar, I would have got something a little bit simpler. But equally, I could take. Actually, maybe the Schwarzschild metric is too complicated for this. Maybe I may not be able to do this in reasonable time. Let's go back to doing it with the Flrw metric. But so in addition to computing, say the Kretschman scalar, I could also compute something like Chern Pontriage scalar, the Euler scalar. So the Chern Pontier Jagen scalar. This is related to those of you who know a bit of algebraic geometry or algebraic topology. This is related to the theory of characteristic classes and in particular the Chern class. So specifically, if you took the integral of the chernpontry Argon scalar over the space time, that would give you a Chern characteristic class. It would effectively determine, if you like the instant on number of that space. If you know about gauge theory, and likewise with the Euler scalar, the integral of the Euler scalar over that spacetime will effectively determine the Euler characteristic of that space, which is of course a kind of a homological invariant. So we can do all of these, all these nice things. I fear that this computation may be a little bit beyond what I can do whilst simultaneously streaming. So in the interests of not eating up too much time, let me have bought that. But I promise you, those do work if you give them sufficient time. Okay, so I'll, I appreciate, I'm getting a little bit lost in the kind of, in the mathematical details here. So let me just. Let's just blitz through and show you, show you the various functions and then move on to some of the cool things that you can do. So once you've computed the Ricci tensor, a natural thing to do is to compute the Einstein tensor. You take r mu nu, you subtract one half R times the metric and then that gives you the Einstein tensor. So if we say matrix representation for that, so this is the Einstein tensor. Let's do reduced matrix representation. This is now the Einstein tensor for the FLRW metric. And if I were to say, I don't know, equivalently, I could do reduced covariant derivatives. Ok, so this is what happens when we compute covariant derivatives of the Einstein tensor for the FLRW metric. But of course, physically, the significance. Well, mathematically the significance of the Einstein tensor is that it's used to define Einstein manifolds. But physically, it's because it's exactly the thing that appears in the Einstein field equations, the governing equations for general relativity. So one thing you could do is given any metric, if I take. I should be clear as well, by the way, I mean, so right now we're using the Schwarzschild metric and things in Schwarzschild coordinates. Or, you know, if I take the Kerr metric like this, we're representing the Kerr metric in Kerr, sorry, in, in Boyer Lindquist coordinates. So if I take its extension like the Kerr Newman metric, so the Kerr Newman metric being the extension of the metric for a spinning black hole to the case where that, where, where you have a spinning black hole that's also charged. And so all these other metrics like Reisner Nordstrom and Schwarzschild and Kerr effectively can be derived to special cases of the kernel metric. But, so this is all represented in Boyer Lindquist coordinates by default, if I take the Schwarzschild metric or the Reisner Nordstrom metric, this is the Reisner Nordstrom metric for a static, non rotating, but charged black hole with electric charge Q. But in all these cases, like for Schwarzschild or Reisener Nordstrom, we're using Schwarzschild coordinates by default. But there's no particular reason why we have to use Schwarzschild coordinates. And the general relativity framework supports sort of effectively transformations between arbitrary coordinate systems. So I could take the Schwarzschild metric and instead I could say something like isotropic Schwarzschild and what it's going to do. So now this is the same metric, it's still the Schwarzschild metric, but now it's represented in this kind of quasi Cartesian coordinate system with X, Y and z. And the coordinate system is so chosen as to make the metric isotropic. In other words, to make the light cones all appear perfectly round. Equivalently, I could take, I don't know, Ghulstrand panle coordinates, sorry, Gulstrand Panleve coordinates or something. And so these are the coordinates, as would be seen from a kind of distant free falling observer towards the black hole. Or equally I could take say Eddington Finkelstein, and these would be the coordinates as seen from an observer that was sort of falling, that was capable of falling past the event horizon. So an observer that's falling with the gravitational, with the gravitational field rather than in the case of Schwarzschild, which is the, which is the coordinate system as seen by an observer that's kind of infinitely far away from the black hole. So these pluses and minus indicate that we've got both ingoing and outgoing components. I think we can say ingoing Eddington Finkelstein and that will take the positive case. And if I say outgoing Eddington Finkelstein, that will give us the negative case. Anyway, so all I'm trying to illustrate here is that we can do, you know, we don't have to represent the Schwarzschild metric just in Schwarzwaff coordinates. We can represent it in any coordinates system that we like. But anyway, if we take the Schwarzschild metric represented in Schwarzschild coordinates and we want to ask, okay, how do we know that this is a valid solution to the Einstein field equations? Well, of course one thing we could do is we could just go check. We could compute the Einstein tensor directly and check whether its components are equal to zero. But another thing we can do is just say solve vacuum Einstein equations of that metric. And what it will do is it will, what this function will do is it will return a symbolic vacuum solution of object that tells us that in this case it's not a solution. Hang on, what have we done? Ah, I know what we've done. I need to do that. Yes. Okay, so we can see that not only is this a valid solution, but it's also an exact solution. What that means is that Gravitas was able to verify that the Schwarzschwaldz metric solves the vacuum form of the Einstein field equations exactly without the need for any approximations or additional assumptions. Assumptions. And so I had to put in a zero here to specify that we want to solve it with zero cosmological constant. If we have a non zero cosmological constant, then the Schwarzschild metric is not a valid solution to the Einstein equations. And whereas if I were to take, if I instead were to replace this with FLRW again. So now this is still a solution, but it's no longer an exact solution. And the reason it's not an exact solution is because the FLRW metric only solves The Einstein equations under a very restrictive set of assumptions. We can compute those assumptions here by saying field, by requesting field equations. And it will return the minimal set of constraints that are needed on the curvature parameter and on the scale factor in order for the FLRW metric to constitute a valid solution to the Einstein field equations. In the vacuum case, if I got rid of this zero and allowed it instead to be a symbolic cosmological constant, now the field equations are going to be going to involve this symbolic lambda, the cosmological constant. If I wanted to, I could see the, the precise, the full form of the Einstein equations that Gravitas is attempting to solve. And then if I say reduced Einstein equations, it will, it will, it will display for me effectively the fully reduced form of the vacuum Einstein field equation. So you can set several of these have reduced to true, but several of them have not. And the, and the, and the ones that have not. Once we've modeled out for kind of symmetries and redundancies, those are the things which become the field equations. Those are the things which become the assumptions that have to be made made in order for FLRW to constitute a valid solution to the vacuum Einstein equations. So we can take any metric that we like and check whether it constitutes a valid solution to Einstein's equation. So if I did the same thing with the Kerr metric, it might take a little bit more effort, but we should eventually deduce that the Kerr metric is also a valid solution to the vacuum equations. Oh, sorry, I should again give this a zero. Let's see whether this runs. It's remarkable how much slower the notebook is when I've got zoom and livestream stuff running in the background. I'm not even the person livestreaming it. But so, but anyway, so you can see again, this has given us an exact solution, but it takes a moment to validate that it's an exact solution. But in this particular case, the analytic form of the Einstein equations that it needed to solve is significantly more complicated. You can see the Wolfram language is not going to choose to display all of that, all that complexity by default. But anyway, so that's what it's solving internally. So that's for the case of the vacuum Einstein equations. But of course we could also consider space times that contain energy distributions. So if I say stress energy, tensor, bracket, bracket, then I'll get a list of the built in stress energy distributions that we support. Again, there's plans to dramatically increase this library, but you can see that we naturally have support for things like Perfect relativistic fluids, relativistic dust, relativistic radiation, electromagnetic fields obeying the Einstein, Maxwell equations, scalar fields, things like that. So if I take something like a perfect fluid, so by default, this is going to give me the stress energy tensor for a perfect fluid distribution in Minkowski space. So this is a perfect fluid with symbolic pressure, P, symbolic energy density U and relativistic full velocity given by u1, u2, u the 3, u4. But, so this is for the particular case of the Minkowski metric, which is by default. But if I gave it another metric, so if I gave it something like Schwarzschild, then I could solve, then I could consider a perfect, what a perfect fluid would do when embedded in a Schwarzschild geometry. So for the case of Schwarzschild, ok, let's reduce that a little bit. You can see the stress energy center is a little bit more complicated for Schwarzschild geometry. And various terms now have dependence on, on the mass of the black hole or the radial coordinate. And in particular, we could say something like stress energy tensor. What is the energy density of the stress energy distribution? What is the reduced energy density when we model it by tensor equivalences? Or what is the reduced momentum density, the spatial momentum? Or what is the, I don't know, what is the reduced pressure of this fluid? So this is, and so all this is doing is it's computing, you know, for a perfect relativistic fluid embedded in a Schwarzschild geometry. You know, what are all these various continuum parameters? What is its energy density, what is its pressure? How does it depend on the mass of the black hole, your radial distance from the black hole, all of that kind of stuff. You know, we could compute, if we want, if we want to, we can compute the Cauchy stress tensor for this, we can compute its shear stress tensor. So reduced shear stress conserved. That's a surprise. That's a surprisingly long time. Let's see. I guess because having to subtract out weird traces and things. But okay, so that's what the, that's what the Cauchy, the generalization of the Cauchy stress tensor looks like for a perfect relativistic fluid around a static black hole. Or I could say, you know, continuity equation. And so what it will do is it will compute the covariant divergence of the stress energy tensor in upper index form, and it will figure out the conditions that are imposed when we say that that covariance divergence has to vanish, which is effectively which is precisely the statement of conservation of energy and momentum in the context of general relativity. Now of course we know in general relativity, the reason why, that's why these continuity equations have to hold, that is why the covariant divergence of the stress energy tensor has to vanish, is because the covariant divergence of the Einstein tensor vanishes measures as a consequence of the Bianchi identities. And so again we could go, and if we wanted to, we could validate any of that. So if we took the Einstein tensor here, I think this is, we computed over here the Einstein tensor for the FLRW metric, if I want to, I could say Bianchi identities and it would give me a full list of the Bianchi identities for the Einstein tensor. And you know, if we wished we could just say full simplify and of course we determine that all these Bianci identities are true, we could confirm that for the force, for the case of the Einstein tensor, for the Ricci tensor, we can even take the full form of the Bianchi identities. So these are all, when we compute these for the Einstein tensor or the Ricci tensor, this is giving us the contracted Bianchi identities. If we do it for the Riemann tensor, it's obviously going to give us the full Bianchi identities, say Bianci identities. For this we get, you can see it's 1024 different equations. But if I say full simplify on that and I wait for a little bit, it will, it will confirm that all these equations are indeed satisfied as indeed they have to be axiomatically as a kind of theorem of differential geometry for any Riemann tensor that's produced from a metric in this way. So anyway, so although the Bianchi identities are a kind of trivial theorem in differential geometry, when they're combined with the Einstein field equations they become a non trivial observation about physics, namely the statement that the covariant divergence of stress energy vanishes and therefore that energy and momentum are consistent served. So anyway, so this allows us to compute a stress energy tensor for an arbitrary, you know, for a sort of arbitrary mass distribution. So actually let's, let's do this, let's do a perfect fluid, but in the FLRW metric, because now what I want to do. So of course the, although the Schwarzschild equations of the Schwarzschild metric is a vacuum metric, the FLRW metric is not by nature a vacuum metric. It's a metric. It's really, it's most naturally considered as a perfect Fluid metric, at least in the context of cosmology. So if you combine the FLRW metric with the equations for a perfect relativistic fluid, you effectively get the general form of the Friedmann equations for an expanding universe. So if I say now solve not vacuum Einstein equations, but solve Einstein equations and I give it this stress energy tensor and I say solution, then it's going to say, okay, so it's deduced that this is indeed a valid solution, it's deduced that the solution is exact, But it's sorry, it's deduce that the solution is non exact. And the reason it's non exact is because it requires the assumption of an additional set of field equations which you can see here. So I've solved the full form of the Einstein equations involving including cosmological constant here. So you can see here we've got a list of field equations effectively in this case second order order ordinary differential equations for the scale parameter A that have ended up involving the cosmological constant, but also the pressure and the density and the form momentum of this relativistic fluid. And so in the general form, these are exactly the Friedmann equations for relativistic cosmology that we've just derived kind of directly from by solving Einstein field equations. So we can do this for any stress energy distribution in any metric and we can effectively we can derive effective field equations. So if we took this thing in addition to saying, in addition to being able to say something like Einstein equations, equations and see and seeing what's the completeness of Einstein equation for that solve, we can also say something like continuity equations and we can see what's the complete set of continuity equations that it had to solve in order to guarantee compatibility with the Bianchi identities. And once we've got a stress energy distribution, you know, there are obviously various other things that we might want to do with it. Like okay, I'm not going to. We probably don't have. Hang on, let's just kill that. Probably don't have time to cover all this in full detail. But if I say angular momentum density tensor and I give it the stress energy tensor, then I'll get an angular momentum density about some symbolic. So this is a covariant rank 3 tensor. If I say angular momentum density tensor representation, you can see this contravariant rank 3 tensor in matrix form. So here it's computed the angular momentum density about the 4 vector x 1 x 2 x 3 x 4 for the case of a perfect fluid in an FLRW geometry. And so that gives us the angular momentum density, which is rank three. But then by integrating that angular momentum density around the boundary of our space time, I get the full angular momentum tensor. So I can say angular momentum equals angular momentum momentum tensorflow of stress energy. That's a representation matrix form. Oh, sorry, no, I'm a matrix representation like that. So, okay, now, and this is going to give us a contra, A rank, a rank 2 contravariant tensor whose components you can see have been determined by integrating with respect to the space time coordinates TR theta phi over the boundary D omega of our space time. So we've just taken these. We've effectively taken the angular momentum density tensor and we've integrated out with respect to one of the tensor components and that gives us the angular momentum. And there are lots of other things that you might want to compute for any arbitrary space time. And we effectively either currently support them or very soon plan to support them. Like if you wanted to calculate gravitational wave data or something, you could take the Weyl tensor for an arbitrary metric. So the Weyl tensor for the FLRW metric should vanish. If this is, I forget which one metric is. Now, I think this is flrw. Yes. So if we say reduced, this is again another rank 4 tensor. If I say reduced tensor representation, this should come out as all zeros because the FLRW solution is conformally flat. But if I did this for something like Schwarzschild, we should get something else. We should get, we should actually get non zero components of the vial tensor, Which we can confirm. Okay, so yeah, we've got a form of the vial tensor that now has some non zero components. And so it's worth confirming. I mean, I'm going to stop to. I'm realizing we're coming up to the top of the hour and I still haven't got on to actually the most exciting stuff, which is all the numerics. I've just been talking about symbolics so far, but, but so suffice it to say, there's a lot more that's going on with the kind of symbolic and analytic side that I haven't shown you. Again, if people have questions about specific things or questions about whether there are certain things this framework can and can't do, please let me know. The chances are, as I say, either it can or it very soon will be able to do those things. But so one important thing to notice that there's actually quite a, there's a bunch of, in many cases quite sophisticated algorithmic stuff. That's going on behind the scenes. So for instance, when we manipulate one of these higher rank tensors like the Riemann tensor or the Weyl tensor, being able to do that in an efficient way and keeping track of all the different algebraic equivalences that have to be kept track of in order to be able to do the kinds of reductions that I've been showing you actually involves some pretty sophisticated algorithms. So for instance, we make extensive use of the Wolfram languages inbuilt implementation of the Butler Portugal algorithm for tensor canonicalization with respect to slot symmetries. So effectively what we're doing is what that algorithm allows you to do is to take the basic problem of tensor canonicalization of a higher ranked tensor like the Riemann tensor tensor, and converts it into a problem of computational group theory, which is effectively, you know, computing canonical forms with respect to a group that's defined by the symmetries of the slots of that tensor. So again, part of the point of this framework is that it's trying to, it's trying to insulate you wherever it can from all that, from all that kind of complexity. So you as the end user don't really have to worry about it. There are plenty of other things that I could show like you know, support for electromagnetic field. So if I, if I say electromagnetic tensor, Schwarzschild or something, I'm overusing, let's do Reissner Nordstrom. I'm overusing the Schwarzschild metric. If I say electromagnetic tensor, Reissner Nordstrom, then I get a symbolic electromagnetic field tensor in covariant form from which I can, then. So this is the, so this is the electromagnetic tensor with you know, scalar electromagnetic electric potential phi and Vector Magnetic Potential A1, A2, A3. And so from this I can compute, say the electromagnetic stress energy tensor, say electromagnetic stress energy tensor. So that's the stress energy tensor corresponding to a vacuum space time consisting only of that electromagnetic field. I could say, you know, electric fields and I get the form of the electric fields components. I could say magnetic field and I get the form of the magnetic field. I could say, you know, homogeneous Maxwell equations. Okay, those are all satisfied. Trivially, I could say inhomogeneous Maxwell equations. These are not satisfied. So trivially I could compute the charge conservation equations, all that kind of stuff. So all the things I'm showing here, for things like the Einstein equations, we also have support for things like the Einstein, for the full Einstein Maxwell equations, thanks to some of the functionality in stress energy tensor. That means that we can do not only general relativistic hydroton dynamics using the relativistic Euler equations, but also general relativistic magnetohydrodynamics in both ideal and resistive cases involving kind of arbitrary electromagnetic fields. So again, I don't want to show too much more of the symbolic side, but what I'm trying to illustrate to you is that the symbolic side is pretty powerful, is quite general, and there's, as I say, if there are particular functions that you want to try and do symbolically involving general relativity or its various extensions, there's a decent chance that the symbolics component of the framework either can do those things things or soon will be able to do those things. Okay, so with that, maybe I should move on and talk a little bit about the numeric side, because that's, that's really the exciting part. I realize we're coming up to the, to the top of the hour, so ostensibly we only have a half an hour left, or I think we, I think we can go a little bit beyond that if necessary and if people want to do so, so. Oh, sorry, before I forget, while I start a fresh notebook, let's go back up to 150%. So if I say resource function discrete hypersurface decomposition. Okay, so let me start by. Let's construct a Schwarzschild metric. Let's construct a static, uncharged, non rotating black hole. But rather than having its mass be symbolic, which is ordinarily what we do, right? So ordinarily with the Schwarzschild metric, we just have this purely symbolic mass parameter M. Rather than having its mass be symbolic, let me give it a mass, you know, actual numerical mass. Let's give it a mass of one so that then our metric simplifies to this. And also let me, let me modify the coordinates so that instead of having these kind of formal symbol coordinates, let me actually use TR A1 and A2 as the coordinate system for this metric. And so now what I can do is I can say I can request a discrete hypersurface decomposition. So I can give it. Let's call this thing decomposition. I can say metric T01. So I'm saying evolve this, this spacetime metric between time zero and time one. Let's do this simulation in the coordinate patch given by the radial coordinate being between 0 and 4, the angular coordinate between being between minus PI and PI 201.5. Okay, and let me start this running and then I'll explain in a moment what all of this means. So if I say, and I can Also do polar graph color. So what I'm effectively doing here is so ordinarily the Einstein equations are a system of, in the four dimensional case, they're a system of 10 independent partial differential equations of mixed hyperbolic elliptic type that are defined over the entirety of space time. But ordinarily, when we want to think about evolution, the evolution of some relativistic system, we want to think about it as evolving from kind of one space like hypersurface to another space like, like hypersurface. In other words, we want to think of general relativity as being an initial value problem. And so to be to do that, we need to find some way of taking the space time and decomposing it into space like hypersurfaces in such a way that the Einstein equations effectively define how one space like hypersurface evolves to the next space like hypersurface. And so to do that numerically, we use this function that's essentially implementing a hypergraph generalization of adaptive mesh refinement. So here you can see after, after, you know, after that evolution from time t0 to time t1,1, we've obtained this space like hypersurface. This space like hypersurface is effectively representing the discrete geometry of what the Schwarzschild metric looks like when we take a spatial slice at time t equals 1. Now, and this is that same geometry, but without the coordinate information. So we're just looking purely at the graph topology. And so this is the kind of thing that one would be interested in studying in the context of the physics project. And again, maybe we'll talk a bit about that later. Later. But so if I say coordinatized polar graph evolution colored 5, I could say polar graph. Okay, so to explain a little bit, so as I say, we give it effectively a spacetime metric metric, we give it a time interval, we give it spatial coordinate parameters, and then we specify how many, what resolution do I want to perform the simulation at, in other words, how many vertices do I want to use in my discrete approximation to this space like hypersurface. And 1.5 is effectively the initial refinement resolution. Because what we're doing is essentially akin to adaptive mesh refinement, except it's adaptive hypergraph refinement. So what we're doing is we start with a hypergraph approximation to the initial space like hypersurface. And then in places where there's high curvature, we refine the hypergraph, and in places where there's low curvature, we coarse on the hypergraph. And that gives us eventually an evolution of the kind that we see here. And so you can choose to tune those parameters, like increase the resolution, decrease the resolution, change the initial level of mesh refinement and so on. 1.5 actually may be a little bit too coarse from looking at these particular pictures. But anyway, so here by saying coordinatized polar graph evolution colored, you can see. So this is the initial space, like hypersurface at time T equals zero. And this is the final space, like hypersurface at time t equals 1. So in this case it's not particularly interesting because we ran it on a Schwarzschild metric, which is of course static. And so it's not particularly interesting to. It's not particularly useful to simulate this, except just to check that our methods are working. Which, which they, which they do indeed. Which they do indeed seem to be. So this is the corresponding evolution from initial space, like hypersurface to final space like hypersurface surface, but here with all the coordinate information thrown away. So we just have the raw graph objects. And the connection to the physics projects is actually rather interesting. Just to briefly summarize. I mean, so as I say, when we do this coarsening and refining, the way that that's effectively being implemented is through a graph rewriting rule or through a hypergraphy writing rule. So if you like, in the process of doing these numerical simulations, what we're doing is effectively amounts to Wolfram model evolution, except, except where the state evolution or the event selection function for that Wolfram model evolution is dependent on the curvature on the measured curvature of the hypergraph. And it turns out that that's actually results in being a remarkably efficient way to do numerical general relativity. And if you go to the, as I mentioned before, I think if you go to the documentation page of discrete hypersurface decomposition, you'll see plenty of pictures like this that you can quite. That you should be very easily able to reproduce in your own notebooks. But an important question is, okay, so how exactly is a simulation like this being done? And how could we do a more interesting simulation like something like a compact binary inspire or whatever? Well, so glossing over a lot of the technical detail, the standard way this gets done in numerical relativity, which is the approach that we use, is to do what's called a metric decomposition or a 3 plus 1 or canonical decomposition. So we use specifically the ADM decomposition, the Arnoit Desmizna decomposition. So if I choose to do that for the Schwarzschild metric, let's see what that does. So what this allows us to do is to split the four dimensional space time into a foliated sequence of space like a three dimensional space like hypersurfaces, related by certain coordinate constraints. So by saying spatial metric tensile, we get a three dimensional metric tensor that represents the metric on the initial space like hypersurface for this Schwarzschild metric. So this is a 3x3 matrix. And then if I say space time metric tensor, this will give us a four dimensional metric tensor for the space time that's obtained by evolving this initial space like hypersurface forwards in time. And you can see here that this space time metric tensor depends on a bunch of these coordinates on a bunch of these functions, alpha, beta 1, beta 2 and beta 2, 3. So alpha is what we call the so. And these functions are effectively how we parameterize the foliation of our space time into space like hypersurfaces in order to obtain a well posed initial value problem. So alpha is what's called the lapse function. It effectively defines the time like distance from a point on one space like hypersurface to a corresponding point on the neighboring space like hypersurface. And beta one, beta two, beta three correspond to what's called the shift vector. And that effectively tells us how we relabel the spatial coordinates as we move from one space like hypersurface to the next. So you can see that the full space time metric tensor depends on not just on the initial spatial metric which you can see in this 3x3 sub matrix, but also on the forms of these so called ADM gauge parameters on the lapse and the shift. So if I take ADM and I say properties, you can see this is a function with quite a lot of properties. ADM decomposition is really, this function is really the thing that's at the heart of the whole numerical subsystem of this general relativity framework. So if we take this thing, you know, we could compute things like. So, you know, gauge conditions are obviously extremely important for. Okay, so if I extract out the lapse function, I extract out the shift vector, we might, we might reasonably ask, you know, what are the constraints that these functions should satisfy? And that depends on the gauge conditions. So, you know, because the Einstein, you know, the Einstein field equations are covariant and you know, general relativity is a covariant this, that means we have a huge amount of freedom to choose our coordinate systems. And so we have to effectively impose certain constraints that tell us how the lapse function shift vector evolve as we move from space like hypersurface to space like hypersurface so there are certain constraints that are just imposed by the geometry. So things like Gauss equations or the Kodaki minority equations. Actually, okay, what I'm going to do is this is going to be too complicated to compute in full form. So what I'm going to do is I'm going to reduce our degrees of gauge freedom a little bit. I'm going to introduce introduce a lapse function and only one component of our shift vector. So I'm going to have B, I'm going to have A be our lapse function. I'm going to have B be the radial component of our shift vector and I'm going to have the angular components both be zero. So now that's now our lapse, that's now our shift. And if I say Gauss equations, this will return the. So the Gauss equations and the Cadave minority equations are effectively these correspond to the particular equations that have to be satisfied in order for our space like hypersurfaces to embed correctly into a, into a background space time. They are effectively, if you like coherence conditions between the spatial form of the Ricci of the Ricci tensor and the Riemann tensor and the space time form of the Ricci tensor and the Ricci and the Riemann tensor. And so you can think of these as being effectively constraints that are imposed axiomatically on our gauge variables. Equally, we can impose our own coordinate constraints. We can say to something like maximal slicing constraints condition. So this is going to impose a. This is a particular gauge choice that we could choose to make when simulating a black hole space time. That's sort of the particular case of maximal slicing. This is a condition that's imposed on the, on the lapse function on A, that's intended to make the volumes of the three dimensional volumes of the space like hypersurfaces as large as possible. And that turns out for various complicated reasons to be quite a stable way of evolving black holes space times. Or we could take something like. I've actually forgotten the names of all of the various coordinate conditions that we've implemented. So we could take, you know, one plus log slicing. This turns out one plus log slicing turns out to be a very good. Oh, sorry, one plus log slicing condition. One plus log slicing turns out to be a very good coordinate slicing condition to use when simulating black hole in spirals. It turns out to give comparatively stable, you know, stable evolutions for those kinds of space times. And in addition to conditions on the lapse function, we can also compute conditions on the shift vector. So we can say for instance, harmonic coordinate conditions or generalized harmonic coordinate conditions. And this is going to give us a list of constraints that have to be satisfied by the components of the shift vector in order for the degrees of freedom, the gauge degrees of freedom to be so called harmonic, so that the gauge equations, the equations for Alpha Beta 1, Beta 2, Beta 3, which will otherwise be elliptic equations, the harmonic coordinate conditions correspond to the conditions necessary for those equations to go from being elliptic to being hyperbolic wave equations. And then we can take things like, you know, the. So the point of doing the ADM decomposition is that it allows us to take the 10 Einstein field equations that are ordinarily of mixed hyperbolic elliptic type and defined effectively over the whole space time and reduce them to a purely hyperbolic initial value for form of the field equations that allow us to evolve from an initial space like hypersurface to a final space like hypersurface using kind of standard hyperbolic partial differential equation methods. So if we take ADM decomposition, we compute evolution equations, it will give us the at least the geometrical form of those hyperbolic evolution equations for this particular black hole space time. And if we take that and we do a full simplify, we should see that those evolution equations are satisfied identically. Because this is a, because right now ADM decomposition is a purely geometric construction. In a moment we'll see how to also incorporate some actual physics in this. But to do that requires, you know, replacing Ricci tensors with stress energy tensors and doing some fancy footwork. But the evolution equations only determine if you like 6/10 of the space time metric because they are evolution equations only on the space like variables. So we've still got four time like component, you know, four additional components that are obtained from the timelike projection that are not determined this way. And so those are instead determined by the so called Hamiltonian and momentum constraints. So if I say Hamiltonian constraint, this will compute this thing here. If I say momentum constraint, Compute, wait, momentum constraints, sorry, momentum constraints that will compute this list here. And so these you can think of as again being additional. So the Hamiltonian constraint is effectively a constraint on the lats. The momentum constraints are effectively constraints on the ship shift. And these are the. And these correspond to the remaining four degrees of freedom that have to be determined in order to close the system of equations and produce something that can actually be solved in a well posed way. And so when we actually, when we want to take one of these things and solve the Einstein field equation. So if I Take this. And I say, okay, so if I take that ADM decomposition for the Schwarzschild metric, and I say solve vacuum ADM equation of adm. That might take a moment. Okay, I'll tell you what, let's start with something simpler because this may be asking too much. So let's say ADM decomposition, I should say, of course, you know, so just like metric tensor incorporates a library of inbuilt spacetime geometries, ADM decomposition incorporates a library of sort of in initial space like hypersurface geometries, initial inbuilt initial values for solving the Einstein equations numerically. So if I take this, I say Schwarzschild time coordinate t, spatial coordinates Ra1, a2. Let's do lapse function 0. Sorry, lapse? Yeah, lapse function 0, shift vector. Lapse function 1, shift vector 0, 0, 0. Let's produce that solution. Do that with zero cosmological constant. Okay, so you can see we've got a vacuum ADM solution. It is a valid solution, but it's not exact. It had to use some approximations or some additional assumptions, and we can again, we can find out what those approximations or additional assumptions were by computing field equations. And in this case it tells us that 1 over R is equal to 0. So that's not very useful. Right? That's effectively saying that these gauge conditions are only satisfied if you are infinitely far away from black hole. So that's not very good. So let's replace that with say ATR a one, a two and maybe this with. Again, let's go back to our old. No, actually, let's not do that. Let's do this. Let's see what happens here. If we just introduce a freedom of the lapse function, but we don't introduce a freedom of the shift vector, so we get nine field equations. The thing remains a valid solution, which we can just confirm here. And if I compute field equations equations, it's going to show, okay, these are the nine additional field equations which effectively reduce the conditions on the lapse function that would need to be satisfied in order for this to be a valid solution to the vacuum ADM equations. And so this is now a system of purely hyperbolic partial differential equations which we can solve using standard numerical methods. And in addition, we can check. So, for instance, is the Hamiltonian constraint satisfied? Let's see, I spelled that. What did I do? Satisfied, which it is. And I can say other momentum constraints satisfied, which they are. So in that particular case, we don't need to worry about the Hamiltonian momentum constraints, we only have to worry about the field equations. So all we need to do is to work out, okay, what, you know, what's a function, what's a form for this lapse function that's going to satisfy these equations. And as I say, we can use kind of standard numerical techniques, which is exactly what Gravitas does internally. And okay, so in this particular case, I happen to know that if we give this a symbolic mass m and I make my shift vector be 1 minus 2 m over r and I solve the field equations, now we get an exact solution to the vacuum ADM equations. There are no field equations that have to be assumed. And again, the Hamiltonian momentum constraint equations are satisfied identically. And so this is how we can determine this is. So we've just computed from first principles the a valid space time produced from evolution of an initial space like hypersurface for the Schwarzschild metric. And so perhaps unsurprisingly, if I say ADM spacetime metric tensor, the thing we get out is exactly the form of the Schwarzschild metric that we're all familiar with. So doing this for something like a, for something like the Schwarzschild metric, as I mentioned, is perhaps not super useful because, because we already know that there's an analytic form of the Schwarzschild metric. Why would you use numerical relativity to compute this? But there are plenty of space times where there is no known analytical form. So for instance, if we wanted to simulate a compact binary inspiral, a collision of two black holes, I could give it Brill Lindquist initial data. So again, I'm going to simplify this a bit by removing the redundant degrees of gauge freedom so we don't get computational bottlenecks too quickly. So if I say spatial metric tensor of this matrix representation, okay, so this is the, this is the initial space, like hypersurface for the so called Brill Lindquist type initial data. So the Brill Lindquist initial data corresponds to two, if you like, two Schwarzschild black holes or two bodies obeying Schwarzschild metrics that are initially widely separated. So in this particular case, in the default case, these are two bodies, each with mass, each with symbolic mass S, and they're located within a kind of cylindrical, in a setup of cylindrical symmetry with coordinates Z equals plus C naught and Z equals minus Z naught. And so what we typically want to do in something like a relativistic inspiral simulation is we want to start with an initial space like hypersurface, like this. And we want to crash these black holes into each other either in a head on collision or in the more interesting case, in a kind of inspiral collision. And so we want to find a way to solve the Einstein field equations numerically for this initial value problem. Okay, so we can do that. So in this particular case it's not, it's not super interesting because I've imposed unphysically high degrees of gauge constraints. But okay, so you know, that's what our, that's what our space diametric tensor would look like. But just as we did for the case of the Schwarzschild metric up here, in principle we can take this brilliant. We can take this representation of the Brill Lindquist initial data. We can say solve vacuum ADM equations. I can give it ADM2, I can say solve that with zero cosmological constant constant. Okay, so I'm running this on a MacBook Air with, you know, while simultaneously doing zoom. So you know, this is not, this, this particular function is not going to converge in any reasonable amount of time. But you know, if you, so but I encourage you, if you have access to a, to a powerful computer or even better, if you have access to a supercomputer cluster or something, you know, I heartily encourage you to go and use this framework and you know, spend a, spend an afternoon or something just crashing black holes into each other. Right? So it's a very satisfying thing to do. And so the pictures I showed you at the beginning over here of the compact binary inspirals, these were produced as high resolution, these are high resolution simulation outputs produced by essentially evolving Brill Lindquist initial data solving the vacuum ADM equations in exactly this way. For those of you who know a bit about numerical gr, we are currently in the process of implementing other initial value formulations of the field equations the, that are better suited for compact binaries and compact binary inspirals, particularly the so called BSSN and CCZ4 equations and various refinements of those. But those things are not yet exposed to the function repository, but hopefully they will be soon. And of course, you know, just as we did for the ordinary Einstein equations, if we wanted to do, if we wanted to simulate not just the evolution of vacuum space times, but actually as is in the case of the, these gravitational collapse simulations, if we wanted to simulate space times involving, you know, energy matter distributions, we could say, you know, take a, we could say take a stress energy tensor and do an ADM decomposition of that so we could say, take the perfect fluid stress energy tensor and okay, if I say ADM stress energy, okay and okay, right, if I do this, This is by default going to be a perfect fluid in the ADM form of the Minkowski metric. So its stress energy tensor is going to look like this and it's going to have these, again these dependence on Alpha Beta 1, Beta 2, Beta 3. Because we're doing this in a space time that's been, that's been, that's undergone a three plus one split. But I could do this in any, in any ADM decomposed space time. So if I did this, so if I say ADM decomposition, let's do Schwarzschild TR A1, A2 and again, let's just do with, let's do that with, with the lapse function being a free, with it being free and the shift vector being constrained. So if I do that now the stress energy tensor is going to be a little bit more complicated. It's going to, okay, so it's going to end up involving this lapse function and other things. So if I say ADM stress energy I could say something like energy density. All the same things that we could do for just the ordinary, for ordinary space time forms of the stress energy tensor, we can also do for ADN decomposed forms of stress energy tensor. And so in particular what we're doing here is we're taking the space time stress energy tensor and we're projecting it in this three plus one decomposition. And so then what would have given us just general continuity equations in the space time case, which are of mixed hyperbolic elliptic time type, now gives us a purely hyperbolic system of conservation equations with the time like projection giving us effectively energy conservation equations and the space like projections giving us momentum conservation equations. If I say energy conservation equation we get this. If I say, you know, momentum conservation equations, we get these and so on. And so in exactly the same way as we did for the space time variables themselves, we can also solve essentially the equations of general relativistic hydrodynamics, you know, the, you know, or the general relativistic Euler equations using kind of standard numerical hyperbolic solvers. And again, so this is, this is exactly the thing that we did, you know, for these gravitational collapse simulations. These are effectively like perfect fluid or perfect relativistic dust collapse simulations that are only possible by taking a perfect fluid or perfect dust stress energy tensor and projecting that in accordance with this, with this ADM3.1 decomposition. So that's really what's going on internally when we run these kind of simulations, we're taking a specification of an initial space like hypersurface, we take the user defined kind of coordinate constraints and degrees of gauge freedom and then we choose to solve those evolution equations numerically using these hypergraph based adaptive refinement algorithms. And then we produce these results. And then because of the design of this framework, once we've got these results, results, we can then feed those back into the Symbolics framework and we can extract things like angular momentum variables, we can do event horizon checking using coordinates, you know, using the coordinate singularities code. We can, you know, we can extract gravitational wave data by kind of computing symbolic violet tensors, all of that kind of stuff. So really the complete workflow of doing an end to end numerical relativity simulation, from initial problem formulation to simulation to you know, to post simulation visualization and analysis, all of that should be able to be done within just a single notebook using us, you know, using a single framework. And that's, you know, again that's, that's sort of one, that's one of the core ideas behind what we're trying to do with this, with this system. So there are lots of other things that I could show, but I've covered, I think most of the main bits of the salient parts of the framework and given that we are coming towards the end of the schedule time, maybe I should, we should, we should take a, I'll stop talking for just a moment and we, we can, if there have been things in the chat which I haven't really been following, then, then we can take a look at those. So if people have questions, things they want me to talk about, things I said they didn't understand, things they want me to go into more detail about, then, then let me know. But, so I'll start to look through the, through the chat questions. Okay, so Krishna Aditya is asking, will gravitas have a quantum advantage? Okay, I'm going to try to explain you, I'm going to try to interpret your question because I know, I'm not entirely sure that I understand it. So quantum advantage is something that people talk about in the context of quantum computers where you say, you know, I've got some quantum algorithm and in principle it offers me such and such a speed up over the corresponding classical algorithm. Everything we're doing here is purely classical. This is just classical general relativity and it's, you know, it's discretization in terms of the Wolfram model. We're not doing anything quantum mechanical Here you may be asking whether it's possible to use the algorithms that have been designed in gravitas on quantum, quantum computers or to develop quantum analogs of them. It's an interesting question. And of course, you know, for those of you who know about the physics project, I mean, one of the kind of core lessons we learn is that anything that involves sort of multi way systems and evolutions of multi way systems, which all of this implicitly very much does, all of those things are in principle kind of quantum, quantumizable. And so it's conceivable that we could produce something that was kind of, at least in theory, a quantum computational implementation of these kinds of algorithms. Algorithms. I'm enough of a quantum computing skeptic to be, to be not entirely convinced that would be a fruitful thing to do. But I'm not, I'm not, I'm not entirely sure that I understand your question. It's as I say, this is a purely classical framework. All the algorithms are purely classical algorithms. So this is not the kind of thing where there's, where there's obvious quantum advantage to talk about. There is algorithmic advantage to using this functionality because as I said, in some sense, as we've shown in other papers, by doing these numerical simulations using hypergraphs, rather than using kind of fixed coordinate system, curvilinear coordinate systems, or cartesian coordinate systems like other frameworks such as GR Chombo or the Cactus framework do, by having our topology be much less structured, we are able to get quite significant performance benefits from that. We can simulate extreme space times without the need to do kind of complicated excision or moving puncture gauge conditions or all that kind of, of stuff. Although Gravitas supports all of that, those things too. But actually in a lot of cases you don't really need to do that. So there are, there are algorithmic advantages to using hypergraphy writing, to doing numerical relativity, but I, I'm not sure it's useful to think of those as being quantum advantages. This is really a classical system. Okay. Andres Monterey Moreno is asking how to make Einstein sum, how to make Einstein's sum for make operations with tensor in general relativity. So I think I kind of covered the, that with, so when I, when I showed, when I was showing off this, I mean, the Symbolics framework, all of this uses Einstein summation convention by default. And in fact you can see it very explicitly in the cases where, where we're computing index contractions. Right. So I can't even remember where I did this now. Yeah. So here places like this, you can see, you know, these repeated indices like sigma that appeared when I, when I was contracting these Christoffel symbols along their indices. All of this is making use of Einstein's symbol summation convention. So we can, so we support. So anything in the Gravitas framework that is of kind of, that is of abstract type tensor supports Einstein summation convention. You can take covariant derivatives of them, you can do index contraction, you can do all that kind of stuff. I don't know if that fully answers your question. I'm not. So, I mean, yes, you can do Einstein summation is the basic answer. If there was a more specific thing you were asking about, then please do, let me, let me know. I just got a message from Zoom that says participants can now see your screen. I hope that, I hope that was a bug. I hope it wasn't the case that participants can only now see my screen. But anyway, so, ok, what else have we got? Tech Riffic says really neat. Okay, thank you. Yeah, I agree. I think this is, this is an exciting framework. Jimmy vay. Jimmy Way. I want to say VAY like Vi, like Herman Vile, but I don't know how to pronounce yourself Surname. Symbolic side is very neat. Application beyond physics into chemistry would be interesting. That's interesting. I don't, I don't quite know what the. I mean, I'm not sure what formal similarities there are between, you know, solutions to the Einstein equations and the kinds of things that chemists would be interested in. I mean, I know that there are for instance, formal similarities between like so in the description of. Well, okay, so particularly in things like solid state physics, which I guess is you could kind of think of as being related to, as being a branch of chemistry. You know, when people are computing like, you know, distortion tensors for elastic solids or they're computing Q tensors for liquid crystals and things, there's a bunch of just kind of general purpose tensor calculus stuff that's probably shared, you know, that's of shared interest between GR and chemistry. That may have been what you were referring to. I don't know. In which case, case, yeah, maybe you can use some of the functionality for gravitas to do that. I don't think this framework is really the right thing to use. I think using something like exact, a more general tensor calculus library is probably the way to go if you want to do computations of Q tensors for, I don't know, smectic liquid crystals or whatever. But again, maybe you meant something else by your question. In which case. So, yeah, please do clarify if you're still around. Okay. Jack Reese. Hello? Jack Reese. Someone I know. Hello. Any book in the works? It'll be cool to see all these in slow mo motion. A book about this framework. I don't think that. I'm not really a book writing kind of person, and I'm not sure this framework is large enough to really warrant a book. I mean. Okay. One thing that's worth saying, by the way, is that although obviously this was designed as a framework for doing general relativity research, I hope that this is a framework that ends up getting used by educators. I mean, in the same way as we saw with the quantum framework. I mean, we originally designed the Wolfram languages quantum framework, again, to be a kind of research tool. But one thing we very quickly found after we released it is that it ended up being used in a bunch of intro courses in foundations of quantum mechanics or quantum information. And so I hope that, you know that if you're an educator who's teaching a course on an introductory course on general relativity or cosmology or something, that you'll find some way to use some of the functionality that I've shown here to help illustrate some of those concepts and help to shield your students from all the. All the horrifying complexity of doing tensor calculations by hand. You know, I think in 21st century, people should not still be computing Christoffel symbols for the Schwarzschild metric themselves. So in that sense, if you're an educator and you want to go write a book that's kind of introducing the, you know, that's introducing general relativity using this framework, I think that's a great idea. You should absolutely, you know, people should absolutely go and do that. I'm not sure that I'm going to do it myself, but yeah, people should do that. You do say it would be cool to see this in slow motion. I agree. I appreciate this has been a very fast paced introduction to the framework, but I've never really. I haven't really talked about the framework in public before. So that was kind of why I wanted to. I wanted to kind of give at least a summary of many of the core features of what this does. I agree. It would be good to do something in slow motion. Maybe one thing we could do, you know, we have both through Wolfram you. And through the. And through the Wolfram Research YouTube channel, there's some provision, I believe, for kind of having slower paced video tutorials and things or even written tutorials that kind of show you in A more step by step way, how to build up and use a framework like this. And I think maybe once, once we're a bit further along in the design, it may be worth. In fact, I think it'd be quite a good idea to make a tutorial of that kind that would be a little bit slower and a little bit more digestible. I'm completely in favor of doing that. Davan V. Says, recently you said black hole creation is too observable in finite observation to an observer from outside. Help understand and visualize. Okay, okay. So I think this person is referencing a tweet that I made earlier today in which I was pointing out this very basic fact about black hole physics that a lot of people don't seem to know, which is that if you have a collapsing star or something, an astrophysic, you're forming an astrophysical black hole. The black hole doesn't form if you're an outside observer watching that collapse. That black hole does not form in finite time. The event horizon for that black hole only forms in the sort of infinite time limit. And the reason for that is very simple. It's because for relativistic reasons, the collapsing sort of sphere of material cannot ever be seen to sort of pass its own Schwarzschild radius, because to do so would involve its co moving velocity going faster than light. And so to you as an observer, you just see the thing collapse more and more slowly and the material appears to get more and more redshifted and more and more distorted until eventually it just kind of fades away. But you never, you never actually see, if you like, the formation of the event horizon. That's why when we, when we look at, you know, when we, when we produce visualizations of black holes, you know, and you imagine kind of stuff being sucked into a black hole, it never falls directly in. Instead, you see the stuff just kind of accumulate around in an accretion disk that surrounds the black hole. And the disk gets hotter and hotter and you get the kind of high energy plasma things that get formed, which ultimately are believed to be, be the origins of quasars around, around rapidly rotating black holes. But, but, but, yeah, but you never see the matter fall past the event horizon because you can't. It's, it's against the rules of general relativity for you to ever observe matter falling past the event horizon. And so, so for that reason, it's really, you know, black holes really only exist in some sense if you fall into them, or if you wait infinite time, if you fall into a black hole. Then, then you would see the surface of that material recede away from you. And then, and then once you're inside, then, then the event horizon is there. But until, until that happens, if you're on the outside, the event horizon doesn't form in any finite amount of time. You ask if I can visualize that. I mean, yes. So in effect, when, when you, when you see this. So that the Schwarzschild metric that we used here is an external black. Is a metric for the exterior geometry of a black hole. And you can see there's a hole in the middle here. Where, where, effectively where the thing is, is ill. Is. Is not def. And the reason for that is because of this, is precisely because of this coordinate singularity. If we take, if we take the Schwarzschild metric and I compute its singularity structure, we get this coordinate singularity at r equals 2m. And so everything, you know, so that's effectively the limit to the radius of any of any compact body that's undergoing gravitational collapse. It can't collapse at 2 or below r equals 2m because it would end up violating. It would violate general relativity. And so that's effectively the thing you see here. So this gap in the middle is essentially the bit of the metric that's missing because it goes beyond this r equals 2m coordinate singularity. And so to visualize the thing I was saying about being an infalling observer, all you have to do is switch to a different coordinate coordinate system, right? So if you switch to Ingoing Eddington Finkelstein coordinates, Get matrix representation like this, okay? So this, this is now the coordinate system as seen by an infalling observer. And in this coordinate system, if we now do, if we now compute metric singularities, Then you see there is only one, right? There's only. There's only this sort of physical singularity at r equals zero. And this coordinate singularity at r equals 2m has disappeared. And this is a consequence of the fact that it is merely a coordinate singularity. It is a coordinate artifact, as was, I think, originally pointed out by Georges Lemaitre. So this transformation to the ingoing Eddington Finkelstein coordinates is a way to visualize exactly that point, that it's only if you're an infalling observer that the event horizon forms in finite time. If you remain on the outside, the event horizon doesn't form in any finite time. If you want to know more about this, see my Twitter feed. Okay, Khalid Al O Taibi says, how does this algorithm that uses Hypergraphs compare in computational complexity to traditional numerical algorithms. Okay, so I kind of mentioned that a little bit. And actually one of the papers that I showed this. Where is it, this paper in particular, where I first proposed this, the kind of proto version of this algorithm did an analysis of this. But yeah, so effectively in terms of the computational complexity, I mean, look, the complex parts in any, in any finite volume numerical algorithm of this kind is computing the fluxes, right? Computing the internode fluxes effectively. Along each one of these, along each one of these edges, we have to compute a flux that corresponds to the, to the flow of information in the kind of, in the sense of characteristic analysis between the, between the values at each of those nodes. And almost always in any numerical algorithm based on finite volume approximations, it's almost always the flux computations that are going to be the computational bottleneck. And so using hypergraphs in that sense doesn't help us at all, right? We still have to do those computations. So it's not going to speed anything up from that point of view. But the interesting thing which I already alluded to is that because we have a much more unstructured hypergraph topology than you would if you just had a fixed curvilinear coordinate system, as standard sort of numerical relativity codes do. Because of that, rather astonishingly, for the same number of points, for the same number of nodes or cells, we can get actually much higher resolution than you could get with our adaptive refinement algorithms. We can get much higher resolution than you would be able to get with the corresponding fixed curvilinear coordinate grid, even if that curvy linear coordinate grid had its own kind of hierarchical adaptive refinement. And yeah, in that paper I do a kind of more systematic analysis that compares the two approaches. But yes, I mean, broadly speaking, it's, I think in four dimension, for four dimensional space times, if I recall correctly, you get approximately a cubic increase in the relative level of resolution as measured in terms of the L1, L2 and L infinity errors on the, on the Hamiltonian constraint. So in other words, you need cubically fewer, you know, polynomially fewer nodes in order to achieve the same bound on the, on the L1 error in the Hamiltonian constraint as you would with a typical numerical algorithm based on kind of on a fixed coordinate topology. So, but yeah, go read those papers. If you want more details or if you have more specific questions about the, about the computational complexity aspects, I can try to address them. The Universe within Federica Beffer all saying, very nice complimentary things. So thank you. David Hanson is asking, does this bring into question the nature of space time? I can remember during the regular physics project meeting, space time looked to behave differently than what tradition would dictate. I mean, so, okay, so what we're trying to do with these simulations is reproduce general relativity. We're trying to reproduce the predictions made about continuous space time. So in that sense, the answer is no for this particular framework. But one interesting feature of this is ordinarily in numerical analysis, this, if you have a low resolution simulation, or you have a simulation where, where you have only comparatively few grid points in some region, then you introduce a bunch of kind of discretization errors, right? You introduce, for instance, you can get the phenomenon where you get kind of spurious waves that get produced around corners and things, you know, between your computational cells. And ordinarily those are viewed as errors that you kind of want to get rid of in the design of your numerical algorithm. One thing that's kind of interesting, though, if we're right about kind of, you know, the Wolfram model approach, and then we're right, we're where we're kind of correct in thinking about the fundamental structure of space time as being, as being combinatorial, then one interesting feature of that is that the kind that those things, those sort of discretization phenomena are in fact, not just numerical artifacts. They might in fact be kind of observable physical effects. And so, you know, one, one interesting thing that you see in simulations produced using the Gravitas framework is that when you have very strong relativistic field dynamics where spacetime is getting stretched and squashed in all kinds of complicated ways, you can end up in a situation where you have comparatively sparse graph representations that kind of essentially lay bare the, you know, the underlying discretization scheme. And when that happens, you can see discretization effects manifest, for instance, in terms of phase shifts in the gravitational radiation. And again, if you go look at the early papers that I wrote about this, about this algorithmic approach, you can see some of those effects being computed explicitly. But essentially you see a phase shift shift in the, in the components of the Weyl tensor that get emitted, for instance, after, after a black hole in spiral, where the, where the degree of the phase shift depends in a very sensitive way on the, on the discretization scale of the underlying space time. So in that sense, we may. You know, one thing that I'm very excited about is using this general relativity framework as a way of probing, you know, possible astrophysical or cosmological predictions that we can make as a consequence of the discrete space time model. You know, essentially we can potentially use this framework to predict places where the continuum approximation to space time that's made in general relativity might reasonably break down in high energy astrophysical or cosmological scenarios. But that's, it's important to stress that's a much more speculative idea. That's really a kind of basic science idea. You know, the focus of this particular talk was not supposed to be on basic science. It was supposed to be on demoing this new Wolfram language functionality which you can all go and use. But there is of course, there is a whole separate interest in interesting basic science. Question of what does this mean for the physics project and is it possible that we might be able to use this to make astrophysical predictions? Tentatively, the answer does appear to be yes, and I'd love to talk about that in more detail at some other point. I have some, so some ideas about how that might work, but it's not, unfortunately that's not the, that's not what wasn't really intended to be the subject of this stream. The universe is. The universe within is asking, if you're working out the collision of two black holes in your model, are you able to see what's happening happening in the rulial and branchial graphs? So with this framework, no, because we, so in effect, when we do this ADM decomposition, we assign these coordinate constraints, we make certain coordinate constraints that constrain our gauge variables. The reason we're doing that, if you like, is we're essentially trying to ensure that we only have one well defined. Absolutely. We are effectively defining unambiguously an event selection function that eliminates the multi way structure, if you like. One way to think about the multi way system is that it's a byproduct of the fact that you have gauge freedom in the model. Gauge freedom in the model corresponds to freedom of choice in how you apply the rules, or more broadly, in which rules you apply. And that manifests in the fact that the multi way system is not merely a path graph. And so in a sense, for the purpose of doing numerical relativity computations, because general relativity emerges from the model as the approximation that you get if you only consider the geometry of the hypergraph and the causal graph and you ignore everything about the multi way system. And so for that reason we're trying to get rid of all the multi way structure, which is why we, which is why we have these very, very kind of hard gauge conditions that are used to Ensure that there's absolutely no degrees of coordinate freedom so we don't get any multi way behavior. Now of course, in principle, one very interesting thing to do again from a basic science point of view is to say, well, let's relax that assumption. Now what we've got is no longer a classical general relativistic simulation, but something more like a kind of discrete quantum gravity simulation that involves multi way behavior and has branchial graphs and you could even consider the interaction of multiple rules and consider rule your graphs and so on. And that's a perfectly interesting thing to do. And you know, for instance, there's recent work that I've been doing with collaborators involved in sort of essentially investigating how one can reproduce predictions of quantum field theory and curved space time using, using methods of this kind. So effectively doing these kind of general relativistic simulations where the, where the gauge constraints are relaxed. So you look at the multi way behavior and then it turns out that certain semi classical correlations that you get from doing quantum field theory in curved space time, you can actually compute directly from the combinatorics of the branch of graphs. I have various papers about that. Again, I'd be happy to talk about that at some other point, but, but that's maybe slightly beyond the scope of this particular stream. Okay, I think we've basically reached the end of the, okay, we've reached the end of the questions that I at least can see. So maybe this is a good time to start to close down the stream. So thank you very much again for coming. I hope this has been vaguely useful. I'm sorry we covered so much material in such a short period of time. Let me just double check. There was nothing particularly that I wanted to show. I mean, there's loads of stuff we could have talked about. I didn't talk anything about the extrinsic curvature tensor. I didn't talk about, you know, other, you know, bits of curvature shouts and tensors and so on. I barely showed the electromagnetic, the electromagnetism subsystem. I barely showed how angular momentum works. We only kind of scratched the surface of how the three plus one decomposition works. We didn't talk about electrovacuum solutions. We didn't talk about, you know, other three plus one formulations of the field equations that are supported. So there's lots of, lots of stuff to play around with that goes beyond the scope of what I showed in this stream. And so if you want to see that or you want to play around with it, please just, you know, go and go and check out the function repository entries, look at the documentation go and you know, look at the GitHub repository. And yeah, hopefully we'll try to get, once we're a little bit further on in the design of this, hopefully we'll try to get a more systematic tutorial produced at some point so that you can follow along, hopefully in a more reasonably paced way and a slightly more structured way than this, more than this mildly scattergun approach that I've taken in this particular stream. But anyway, so thanks very much for joining. Thanks for your great questions and yeah, we'll see you soon. Thanks.