Overview of What's New and Improved in Version 14

Hello everyone. I'm Jamie Peterson, Director of Wolfram youm, where you find resources to explore computational fields and learning Learn more about Wolfram Tech it's my pleasure to welcome you today to our first webinar in the new Inversion 14 webinar series. Today we've invited John McCloon, Director of Technical Communication and Strategy with Wolfram Research Europe, to give us a big picture overview of the new and updated technology and functionality in wolfram language version 14. Over the next few Wednesdays, we'll continue to bring you an impressive roster of Wolfram developers to present on their areas of specialty. Last week I was listening to a panel discussion taking place at our Wolfram Neural Networks bootcamp and it really inspired me to hear others reflect on the growth and strength of this computational tool that began as version one of Mathematica 35 years ago. I'm going to put Stephen Wolfram's release announcement on the screen here. Wolfram Language has an incredible foundation and has been carefully built over the years, version after version to develop a seamlessly integrated system that provides a breadth of coverage like nothing else out there. I encourage you to read Steven's blog where he talks more about his guiding philosophy and new initiatives and how they relate to our latest features and functionality. To try the examples from today's presentation, you will want access to version 14 and we'll share a free trial offer so you can get started right away. I'm going to ask a poll question to the webinar audience now about whether you've already upgraded to version 14. This is helpful information for us to know how many have already had an opportunity to work with the latest version. We have people joining on our YouTube live stream as well. And for those of you on YouTube, please feel free to type your responses, comments and questions in the chat. We'll be able to share those with our webinar presenters during the live stream. So we've got that poll question out there. Thank you for answering the question. Let me take a peek at how those responses are coming in. That's great to see that information. Thank you. As people finish up submitting their responses, let me point out just a couple more things in the webinar interface. A download for the notebook appears in the chat. We'll be adding notebooks each week as we continue the series and we hope you'll plan to join us for all four Wednesday webinars. Let me switch my screen here. I'm going to show the webinar series, so if you've already signed up for this series. You'll be getting reminders for each of these sessions coming up. Here's our list of presenters and here are the titles of each of the sessions in the series. We'll include a link to this page in our recording notification email so that you have a chance to sign up for the full series and participate in all these webinars if you wish. We hope that we'll be seeing you there. We have staff on hand to provide typed responses to questions as we go, so please feel free to type your questions in that questions pane and we will have a few minutes at the end for Q and A with John. So without further delay, here's John McLuhan with our featured overview presentation. John, I'll hand things over to you.

Thank you, Jamie. So in contrast to Stephen's blog, I'm going to take a little bit more of a granular feature by feature view of what's in UN14. So I'd still encourage you to read Stephen's blog for the narrative of how it fits into the vision, but I am going to dot through things quite quickly, so do come back for the other webinars in the series that Jamie just showed you. Because there's so much to cover, each feature will only get a very brief mention as we go through it. So let's get started. Sharing screen here. Pick the right screen. There we go. So it's always worthwhile trying to summarize the whole thing at the beginning, and it's a little bit hard to do because this is very much a solid across the board kind of release. So these are the sections I'm going to be going through, but I think it's worth pointing out there's quite a lot in infrastructure improvements and things like performance generally, and also a lot of bug fixes and perhaps more than many releases we've added a lot of functionality without adding to the function count that much because there's quite a lot of things here and I'll point some of them out as we go where the functionality is improved or there's been new capabilities added, but actually is just extending the capabilities of the existing function set. So I'm going to start with machine learning and AI only because it seems to be one of the more exciting topics at the moment, and then I'm going to kind of gradually get into narrower areas as I work down. So on the headline side is we have more large language models than we used to before, so that's both in the chat notebook and also in our core LLM infrastructure. So Let me give you a sense what that looks like in the context of a chat notebook. If I switch here to a fresh chat notebook, this is where we've extended the notebook paradigm to having conversational AI. So the chat notebook lets me ask it to help me write orphan language code or write poetry or whatever I want it to do. But I've got a notebook that I can replay the workflow later. And so here it's helping me. Slightly misinterpreted this one, but it's come up with some code here for what I think it might have meant. It's. I don't know why it's chosen to fill in zero as one of the values, but it's generated a plot of two points. Now a couple of things that the main thing that's changed here is the model choice. So up to now we've been using OpenAI's ChatGPT entirely. If I just open the toolbar here. Oh, by the way, this is a minor new feature that the toolbar is collapsible now so you don't have to have it permanently turned off or on. If I go to the LLM, pop up here and go down to models, you'll see now that we have choices of OpenAI, anthropic and palm. And when I go into those I can see all of the available appropriate models from OpenAI. So I can switch between. I think we had just 3.5, 3.5 turbo and 4. And now you can choose much more fine grained between the model choices and I'm going to show a couple of these. So as say Anthropic is one of those. Let's just cut this out here. And I didn't make the switch. Let me put that back on. I didn't actually choose one. I'm going to switch now to one of Those which is OpenAI's GPT Vision Preview. And what this is is now one of our first multimodal models. So one way we can use that is simply using image inputs within the chat. So I could say, for example, describe, describe. If I can type with live this plot and I have it kicking around here on another screen to save me hunting it out, I'm going to paste a bitmap image that I've grabbed off the Steven's blog post and now we can take that mixed input of words and image and the prompting says describe it. So here's the description of what it thinks it sees and I'll just queue up and say recreate the plot as my next input and hopefully it will do some reasonable job of writing some Wolfram language code to try and recreate that plot. And it seems to be doing the right kind of thing. And now it's evaluating to give me a picture of it. So this is part of a strategy that we've had from the beginning. All of the functionality in for LLMs is label things like LLM synthesize, not chatgpt synthesize. Because the plan was to make this an abstraction layer where you can access all kinds of models in a completely consistent way. So that's multimodal, like I just showed is things like Anthropic. So here's doing this through code where I can say LLM synthesized as I could in version 13.3, but now I can say the evaluator is going to be the model coming from Anthropic Claw 2. And when I ask it the question what AI model are? You can see it's now, unless OpenAI is deciding to fake it, that's obviously gone to the right service and that opens up the ability to think to orchestrate multiple LLMs. So I did this little experiment just while looking for examples, which is to ask the LLM to synthesize something crazy, which is estimate of the oldest living duck. But I've done that over a choice of models between our fault chatgpt4 and the anthropic claw2 and done that a whole bunch of times and charted the results. And we can see that Anthropic is a bit pessimistic about the lifespans of ducks compared to OpenAI's. So now the ability of using one AI to check another, or getting mixed voting on things and aggregating the results of different AIs that all becomes easy to orchestrate. Also on the list is Wolfram GPT, which is a fine tuned model. It's shown on that list under OpenAI and that fine tuned to do a better job in many cases of generating Wolfram language code. So if you're using the tool as a code assistant or code writer, it knows the fine tuned version knows Wolfram language better. So there's some examples where the generic ChatGPT has done something that's plotted vaguely right but has not got it quite right enough. And so it's done a region plot with the wrong kind of region plot. And here's the correct one. And I've got various different examples of where the options just never quite set right. But the fine tune one knows more about entities and more about options to be able to Orchestrate the right code rather than hallucinating the names of options. Now another thing that we're doing this space is trying to now start using this infrastructure. So one of what will probably be a whole collection of potential future functionality is text Summarize. In a way, it's getting most of this for free from the LLM that here I've asked it to read the book Alice in Wonderland and then summarize it in a short summary of what it found in the contents. And there's options for suggesting a title, rewriting the thing, making one line, summaries, descriptions of it, listing the topics, things like that. It does take care of a little bit more than just calling the LLM though, because this will handle large text beyond the attention span of the LLM. So it when necessary breaks in its chunks, gets a summary of each chunk, and then gets a summary of the summaries. And so there's a little bit of recursive machinery in place just to make sure that this just works. Now of course, in more traditional machine learning we've got the Neural net repository which is a repo where you can automatically download pre trained neural networks either for immediate use or retraining or repurposing using the neural net framework. That's now at 150 models. Here's some of the ones have just been added doing things like image description. So that's not just saying it's a tiger, it's saying it's a tiger with a happy look on its face in front of some green leaves by a path full content description. There's video content identification and a whole bunch of things that cover areas we already have examples for, but these have different properties and capabilities. And another synthetic image generator where you say I want an image of this and it will imagine one for you. There's also a new repository which is the LLM tool repository. At the moment it's just got an initial set of placeholder contents. But for those of you who know our LLM framework, we have the ability to mix the fluency of LLMs, to write text, to understand text, together with the accuracy of computation. And you can make your own plugins. But the idea is that this is a place where you can submit plugins that do particular things. And at the moment we've got some core things that are useful, like be able to fetch your web page. So if you want to have a tool that says answer a question, but if necessary read this web page to get the latest information. The web fetcher is a tool that can plug in web image searching searches for our function repository and Wolfram Alpha and Wolfram Language Evaluator. These all things that we. Some of these things are already built into some of our things like the chat notebook, but they become easily accessible to you to write LLM based functionality where you say and I want it to have the ability to execute Wolfram language and I want it to have the ability to search the web without you having to write those. Hopefully over time many of you will submit interesting tools that are useful to LLMs and there's a whole mechanism like our function repository for submitting them, so they're discoverable and usable by everyone in the Wolfram community. Now I wanted to show a couple of things that are maybe I'll just do one of these before moving on to the next section of Things where our sort of obsession for making things join up keeps making us revisit functionality that seems long since finished. And model fitting, perhaps the very simplest form of machine learning that there is is still getting improvements in this case. I'm taking some data that has uncertainty on it and I'm just going to fit a straight line to it with linear modelfit, which is functionality we've had since the very beginning of the Wolfram language. But what's new here is that I can take into account the error bars and so this has very tight error bars on it, the second point. So it's very confident what its value is. But the value 8 has very large error bars and so we don't have very much confidence in it. So what we want to be able to do is to fit that taking into account those errors. And I can rip out the central value of the data and redo it without the error bars, which is what we would have done in the past with this data. And you can see we get different models and actually showing them together, you'll see exactly what it's done. The model that has been told to take into account the error bars is basically ignored. The really uncertain point, it's had a slight influence, but hardly any. It's drawn the line just down below the endpoint, but the one that couldn't take into account the error bars has given undue weight to that point and pulled the line disproportionately downwards. But there's no new functions here. This is linear model fit, which has been around for years and years and around for representing the error on the data, which has been around since somewhere around version 10, I think, was when around was added. There's Other infrastructure that's just being including things. Bayesian optimization could be quite slow. So now there's a progress tracker and the ability to restart and continue optimization from a checkpoint that's been added. And in the world of neural networks, onnx is this import export format for neural networks. And there's further improvements in the range of things that we can import and the speed at which import and support for GPU within ONNX import as well. Now, something that touches, of course, a lot of people is the beautiful visualizations that you can get out of the Wolfram language. And there's two rather different improvements going on here. One is very much kind of practical application function for, in this case, high dimensional data visualization, and the other is an infrastructure improvement. So the issue with the high dimensional data visualization is often that you have tabular data that has many columns. What do you do with that? This one isn't very many columns, but it has got three. And so typically you want to plot age against cholesterol or age against blood sugar, or cholesterol against blood sugar. And there's this family of functions now that do that automatically for you, taking advantage of the things that were added in the last couple of versions for better axis control, multiple plots with aligned axes and the like, which has set us up to be able to do this now. So the basic one is pairwise list plots that just plots one against another. That's a bit small. Let me just make this a bit bigger so you can see what the labeling is on this one. So you can see here that we got age against age is the boring, trivial plot, but here's the age against cholesterol, age against blood sugar, cholesterol against blood sugar. And there's also some detailed controls over obviously the style, like all of our plots, but also the ability to decide if you want to show the full grid or you want to show the upper triangular or the upper triangular without the diagonal or the lower triangular. So you can decide which of these things you see. Personally, I quite like the full grid. It seems more pleasing to me than triangular plots. And there's a few other things in this family. Pairwise density histogram shows us how many points that we have for each pairing. Pairwise smooth density histogram is the same thing, but treats the data as continuous rather than in discrete bins. And a couple for distribution comparison. So pairwise probability plot is one, and pairwise quantile plot. One of these is known as QQ plots. Very often they're a little bit harder to interpret so this sort of general, direct now documentation of trying to help not just how does this function work, but how can you practically use it. So this is out of the documentation gives to you the kind of shapes that you might see and how you interpret those. So whether one data is skewed compared to the other, whether the probability of one is being higher than the other is greater or less, and all the different sort of arrangements of how those plots might relate to each other and how to interpret. Now, the other thing is, as I say, much more in the infrastructure space adds further improvements to texture mapping. So we've had the ability to map textures for a long time where I want to just take a photograph of, of a material and overlay it on a plot to make it look like it's made of that material, or for overlaying additional information, like contours that have been calculated in, in some way or some density, something like that. The textures now have a whole range of mappings so that you can decide the projection of the relationship between the thing you're mapping onto and the projection of the planar image that you're doing the mapping. And it just gives you fine detailed control over making sure the texture lines up the way you want it to, rather than just being slapped onto the graphic. And this is supported across all the main 3D primitives and also fitted with plotting. So, for example, here's a simple demo. I'm getting a particular texture. Let's have a look at what that looks like. Whoops. So this is left out the word texture, but here is a projection of the Earth as a bitmap image. And I'm overlaying that onto the sphere. But to get that right, I'm telling it that the texture mapping is spherical because we get a different alignment of the image if it was plano or cubic or whatever. But this way we don't get any kind of weird bunching around the poles or where the image joins up. It's mapped it correctly. Now, interestingly, together with improvements we made to the way that the camera can be controlled in recent versions, so that we can now place the camera inside the bounding box. This also, as a side effect, opens up the ability to do something that's done as a cheap trick in lots of sort of game and VR worlds, which is to place the camera inside a textured sphere and as a way of giving you a background that you can actually that respects the viewpoint. So here I've done a dropped a torus into a 3D graphic, but I've mapped a texture onto a sphere of some beach scene, but the camera is inside the sphere, so we're seeing the inside of the ball from outside. And here's putting the idea together with the previous one. So here's the Earth in some kind of spherical map of the universe. So, first one, something to use straight out of the box if you're in data. The second one is if you're building your own visualization routines or you really want to customize the look of some of the built in ones, then that's all become more powerful. Okay, I've made a section out of language and performance, but actually there's performance things in a whole bunch of places that I haven't particularly grouped here. But I've put some that are very much just about performance together in this space. Now, some of this is pure infrastructure. And the first one is in that space that we added units quite a few years ago now. And units were very easy to add using the symbolic language. But in fact I mocked up the first prototype implementation before it was moved into the kernel. But just so dropping symbolic rules on a wrapper means that there's a performance trade off. So you can manage the units yourself on data by throwing all the units away, you canonicalize and then turn it into numbers. And that's faster. Or you can avoid mistakes by making all the units are handled correctly throughout the calculation. And we're trying to get rid of that trade off. And so in the last couple of versions, units got faster, they got faster again. So this fairly trivial example I measured on my machine of generating 10,000 random numbers in random units and then converting all of those into a common unit system of miles. I can do those 10,000 on my laptop here in 0.03 seconds. I measure that to be about seven times faster. It depends what you're doing. There are some more contrived examples that are kind of the order of a thousand times faster. But the realistic kind of improvement, I think is more of this kind of level, but still enough that it pushed that point that you stop using units and work with your raw numbers seven times further away before it becomes infeasible. The next one is less automatic. You have to think about using these things at the top level. But we're using, we're partly building them because they're behind the scenes to help us make things faster. There's a story that's been going on for several versions of fast structured matrices. So one of the beauties of the Wolfram language, we've got very General data structures. I can make a matrix that can contain anything, it can contain numbers, but it could also contain pictures, documents or whatever. And it's totally arbitrary in shape, so it can be ragged and multi dimensional. But there are plenty of things where you get very structured matrices of numbers as a routine thing. And we've been adding more and more of these ways of saying given that I know this is going to be symmetric, I represent this as a symmetric matrix object. And the trade off is that you can often use much less memory, you're not storing redundant information and there are algorithms that are higher performance if you know upfront you have a certain structure or they're more numerically stable if you know there's that front structure. So these are the four new ones that we've got. And we've also extended the number of operations that know how to behave correctly with structured arrays before you have to just turn them into a regular array and do things the slow way. So this example that I've got here of just generating random circular unitary matrices, a thousand of those and then representing them as unitary matrices and doing inverses, that inverse is six times faster because it's fairly trivial to you. Invert a unitary matrix compared to one where you don't know its structure. As they were going to be using that behind the scenes in things like NSolve that we can, where we know these things will come up but they're exposed to you to be able to write faster code for mathematical type problems. Another long term story for us, the compiler where you're taking the flexibility of the Wolfram language, but you're giving it upfront information about the types of and it can make compiled assembly language for your CPU on the fly and you get the performance of C code or these other sort of compiler based languages like Julia, but with the power of the Wolfram language it's a long journey. There's a lot speed to do to have the broadest coverage that we can. But three new functions are now compilable and we have also as part of that story we're building more of these compiled data structures that you can use within the compiler or you can use just in a standalone way. So even if you don't want to go near the compiler, these data structures are usable in top level code, but they bring that trade off that if you know this is the appropriate structure, you can do fewer things with it, but the things you can do with it are faster. For example, here I'm taking the built in English Language Dictionary 92,000 words for our small base dictionary and I'm representing it in regular Wolfram language. So all I have to do is get the data. But I'm also making a string vector, one of these new types data structure that I'm calling ds. And if I want to do operations on that, I could do them two different ways. I can count the vowels in each words because string counting is one of these limited operations you can do with the string vector and add them up. So here's the total number of vowels in the dictionary and I can do the same thing with the regular structure. But you can see here I've got three times faster and doing things like counting. Oops, the what am I doing? I'm counting the number of words that end in ing. And again I can do that using string match on the original data. But here we're getting. I can't do that arithmetic. 0.02, 0.05, about four times faster. So when you really need performance, there are more and more ways in which you can optimize your code whilst not having to give up on the ability to write quick, quick to write sloppy code, to get things prototyped quickly. In general data structures, there's a few things in the programming space, a new commands, I'm not going to go to those, otherwise I'll ever run on time. And a few things on debugging and robustness. So there's now you can group unit tests together into intermediate tests. So a typical problem might be you want to test whether a function works on a database correctly. Well, you may need to make intermediate tests to populate the database, set up the database, populate it with values and then check whether you can run the operation on it. And you want to check, do all of those three things and check that all working, but report them as a single test result. So it's really just organizational. And there's some tools for writing more bulletproof code where you can do argument checking, something we added about two or three versions ago and now works on operator forms. If you are, if you know what that means, you will probably be pleased to have it. If you don't, you probably don't care. Okay, let's go into now one of some data. So for quite a while we've been building out all kinds of image, audio and video processing. And so there's still plenty happening in that space. Some of it pure infrastructure again, some of it benefiting from the new machine learning world and also doing things with external services. So one thing that is using the Fast changing machine learning world is we've had quite a while sort of classical image processing, which is you take an image and you do filtering on it to try and clean up or extract things you don't want to see, accentuate features you do, you segment the image into bits that you're interested in and then you do measurements or counting of the things that you've segmented. We've now added this new collection of being able to segment based on semantic machine learning based backends. So instead of segmenting this image the way that you would do in a classical image processing world of saying, well, maybe we're going to segment things by color because we want things that are dark, but then how do we make sure we pick out the white part of the face or maybe by texture. We want things that have high entropy so the fur will stand out more than the T shirt. Now we can segment them by what they are by puppy, ARM and T shirt and we get a segmentation of that by what it represents in the real world by understanding the image as these things all join up with a lot of the other functionality. So I can segment this against a seed point. I've got a target pixel in the middle of left hand Puppy and I can pull out a mask from that which then I can automatically use to crop out the image, remove background and then join that with Image Synthesizer. We've had for a while here. I want three lines of code. I picked out the left hand puppy and place it on a beach. That's pretty realistic looking recreation. So that's supported across a whole bunch of things where you think this, you know, you would find this useful. So support in filtering in components, but also things like image cases, image contents, remove background, inpainting all of the things, you can now have options that can use that. So inpaint, I can now just give the pixel of one of these birds that I want to inpaint and the semantic selection extends that pixel to the whole bird that is in and in paints its result. And so we can just remove the object from, from the picture. The next one's just a nice utility function, but it's a natural extension of what we've done in the past. A couple of versions ago we added the ability to make images. We're now extending that to a 3D version with Tor 3D video. The idea is you take some thing that's 3D in the Wolfram language. In this case, I've taken a plot and you give a specification for how the camera is Going to move around that. So I've set here the angle of view, the point in the image I'm interested in and the camera position. But I've made the camera position dynamic according to time and there's a few other parameters. And the result is I get a video that in this case does a flyby, but not just a straight flyby. It's going to focus on a point on the left hand ridge of that plot. So as it flies past it, it swings the camera around and points back as it backs out the other side. So all of the properties of the camera are completely interchangeable. And I forgot to regenerate this image. Yes. Let me see if I can just run this quickly because I switched machines after I wrote this talk. Now let's forget this. That's going to take a minute to run. I'll come back to it. So in this case I'm changing camera position in a totally nonlinear way. See the result? A few seconds. Another thing that is pure infrastructure is we added video relatively recently. Once we built out all of the processing, the audio components and the image components, we then added video so we could automate the pipeline through whole video sequences. The back end's been improving. There's about 500 codecs now that we can support. So even though it looks like three types or four types of things like MP4, AVI or whatever, actually internally video is quite complicated. And so we need to make sure all the different encodings and compressions are supported. So there's a bit more of that. But we also now properly support multi track video. So I was going to run this live, but the previous video hasn't finished. It will finish in a moment. This was my less serious disco dancing California video with my non linear camera angle with multitrack video. This video, at first glance it seems like a video, but if we ask for more information on that video, we can see inside that there is one video track. Sometimes there can be more than one, but there are multiple audio tracks. In this case, one of those is the sound of the bird. But there are two audio description tracks that say things like this is a Goldfinch or whatever it is, bullfinch. And the second one is in German. And we've got two subtitle tracks, one in English and one in German, that presumably match up to the audio tracks but don't necessarily have to. So now we've got the ability to pull out the individual tracks. So if you want to process those different audio tracks separately, I can pull all three out into their own object. And we can also pull out, let's run this live individual tracks. So here I'm saying I want the second the subtitle tracks. And here we're getting the timestamps and the. And the text and we can import and export those. So now we can build, you know, have build systems that take multiple audio tracks and assemble them into the video or we can analyze different parts of a video or in different ways, new external services. So speech synthesis we've had for a while, but we've added 11 labs in Google speech Speech to that, which have really quite high quality services. You need to add an API key to those to have these functions work. So eleven Labs has lots of different choices of voice. But actually one of the things that's kind of neat that I haven't played with yet is you can upload 60 seconds of your own voice and clone your voice. So you can now do speak synthesis in your own voice or in a celebrity voice by uploading content and having it learn how to synthesize. And the example I don't know if you've seen on Community, you'll see somebody made something already using that to make a virtual Stephen Wolfman. I have to say it sounds pretty convincingly like it. There's also some improvements to existing functionality in Audio Time stretch and Audio Pitch shift. So this is kind of auto tuning where you can take a standard problem I have, as I'm sure you're aware, I talk too fast. So when I do video recordings, sometimes I want to take the audio track and slow it down by 10%. It used to be that if you move more than about 5 or 10%, it really starts sounding quite robotic. And we've now got quality improvement where you can slow it down with the same pitch and it still sounds natural. Or you can change the pitch and maybe speak higher, but without making it faster or lower. And again do that without it sounding robotic and like I'm just talking slower. Well, let's go into some domains now. We've got some things that I've put into the engineering space. They're not strictly engineering, but that's a good way to group them together. And there's a big old story that's been going for some time in partial differential equation modeling that the story continues with some nice things in this release. The basic story is that we've been building a proper finite element solver and that's been behind the scenes getting better and better without really changing anything. On the surface, it's just able to solve more and more corner cases and give more high fidelity simulations of PDE type models. But along with that, something that is more visible is we've been building a layer on top that can encapsulate how you set the problem up, because PDEs are pretty complicated to set up sometimes. And so we've been building this language representation of multiphysics that sits on top of the PDE solver that lets you describe things from the physical world. So in this release we've got electrostatics, fluid flow models and an extension to the solid mechanics model. And there's also one which is really physics, not engineering, but I've grouped it here because it's part of the PDE story is Schrodinger equations. So let's look at one of these in detail. In this setup I want to stretch and you can see the result here already that I've visualized. I've got an object that is made of some material and I'm pulling on one end of it and what shape will it stretch to? And the gray image is the original and this is the exaggerated stretch and it's colored by displacement, but I could color it by stress or strain. But how do we set that up? Well, there's some variables we have to do a bit of bookkeeping to say what am I going to name the different parts of the solution and some parameters that set up the material. And this is the thing that's new here. We have some new hyper elasticity models. So if we've got a material that we know is neo hook in, we now specify that as part of the way that it stretches and some properties that are related to the material. This is all connected in with our entity framework. So if I knew the material, I wouldn't need to specify these properties. I could just say this is made out of aluminium sheet and I wouldn't then necessarily need to say which of its material properties that could come out of the, out of the knowledge that we have with aluminium. And I'm setting up the problem, which is to say it's a solid object. We've got a boundary that has a load on it. So there's a weight stretching it and there's some details describing where that stretch is happening and how much force in what directions are set and a fixed boundary. So I'm basically saying here I've got a sheet that's, that's solid, that is being pulled at one end and held at the other. And that's then is used to set up the problem. Now I didn't need that. You probably could have solved this. I don't know if the solver was ready before this was available, but you don't need this functionality to set up the model. But if you actually want to set up the model by hand, the partial differential equation you need to describe is a bit complicated. Now I've chosen this one because it's particularly horrendous. Some of the others have much simpler PDEs, but in the end it's, it's much, much simpler to be able to talk about things in this high level way of solid components and boundary values than to spell out the details of the mathematical description. I can then pass that into ndsolve by just saying, well, here's the model that we've set up the parameters and then plot the result. So that's the basic idea, but the story extends over quite a lot of types. So here's the same thing going on where I've got some boundary conditions and I'm solving a differential equation. But here's the problem set up is to say that it's a fluid flow component. I think the 000 here says that there's no inflow or outflow. It's a fixed sealed system. And in this case I'm not specifying the details. I'm giving a material out of our, out of our NC system. Say that I've got glycerol in this box and I'm also setting up from the geometry framework the shape of the space that it's in. So we got a kind of pillar in the middle of this box and my boundary conditions are setting up some, some drive along the top edge. Maybe it's got a conveyor belt or something that is stirring the system. And here's the result that we get. Now this is also set up to work with parametric solving. So if you are going to want to solve it for lots of different values. So this time instead of saying it's glycerol, I'm saying for a given viscosity level we can get these parametric functions to stop you having to resolve the problem over and over again and then allow you to efficiently be able to build a family of solutions. So here is the animation of what happens as the viscosity goes up for that plot. And actually it's a little bit easier just to pause it and drag through the video. What you see is that at low viscosity we get two vortices at the top, but as it gets thicker then you end up with one vortex on the top right. And as it gets thicker still, you end up with the material just going around the outside of the pillar. Well, there's still a slight vortex, but it's gradually vanishing Electrostatic. Same kind of thing, but with electricity and charge and magnetism type problems. And the Schrodinger equation is the same kind of thing. Our Schrodinger PD component is something that comes up in quantum mechanics. So here I'm looking at a wave packet hitting a barrier and scattering. But again, without having to go into all of the details of the pde, I can set that up in. You know, it's not really trivial. You need to understand what you're doing with this. But there is a relatively simple way of specifying the system of equations that you want to solve. Now, because these things are relatively complicated, this is an area where documentation is more important. So we've added some new monographs for completely worked problems that show you the whole stages of how you set it up, how you compute with it, how you analyze and interpret the results as a kind of model versions for you to follow rather than the pure this is how the function works documentation. Oh, and the heat transfer PDE component also has some new properties. Now, a different space in, in the system modeling world. And there's a couple of things here. 1, Well, a couple of things in the, in the modeling side. And also I'm going to show something that is kind of trivial but I really like because it's, it's a, it's part of our whole design principle and that we're not letting go of. So let's start with the practical things we've had in the numerical space. Lots of structure for handling uncertain numbers. And we are bringing that into, in an elegant way into system modeling. So the challenge here is I've used Wolfram system modeler or some other Modelica compliant tool to build this system model. In this case the systems I've just put together a resistor and a capacitor and inductor and electrical source. So it's very simple electrical circuit. But this could be some complete system of an oil refinery or the mechanics of a car. It could have thousands of components. And the typical thing you want to do is model that and say what will happen when we run the car or turn on this signal to the system. But what we now have with system model uncertainty plot is a simple way of being able to say, well, that R. We don't actually know what it is. Maybe it's not a resistor, it's something in the real world that we don't really know what its resistance is. Maybe it's temperature dependent or maybe it's some crazy. I picked a random resistor from a box and I don't know which one I'm getting because we forgot to color them. Who knows. But the result is. I get the blue line is the. If we were on the mid value a 4 and a half ohm mega ohm resistor we would get that perfect simulation. That's what we could give you before version 14. But with version 14 we can start giving you error bands here that says depending on where in that range it is, here's the range of possibilities you might get out. And that's taking into account the whole system simulation. Because you know, it might. It might be there's some other components have a damping effect that this thing doesn't matter at all. Or it may be that there's some instability that this actually makes a massive difference and we need to take into account the whole system to simulate it. There's a collection of new free modeling libraries. Two of those are kind of designed as serious professional tools. So aircraft and hydraulic modeling. So where I had in this components like inductors and capacitors and resistors then you have components that are used in building aircraft. I don't know the details. You can imagine the kinds of things like aerofoil or wings as components. Likewise in the hydraulic fluid space. And there is a third library which is not really intended for professional use but is set up to give you all of the components that you would need to teach a mechanical engineering course in a typical university undergraduate degree. So meant as a kind of teaching collection. There's also another slightly more subtle collection of solvers for system models which is input output response that is really designed for dealing with mixed discrete time and continuous time simulation. So the challenge here is that the real world is mostly in continuous time, that the temperatures arrive smoothly. But the controllers that we use to monitor and make decisions in the real world to have a clock and work on discrete time. So this is the very simplest example I could find which is a sampler connected to a driver signal. And we can see here the results of the simulation that the underlying signal has been smooth. Our digital sampler has followed very discrete steps as its clock kicks in. And again doing that over complex systems of many components or thousands of components becomes a non trivial task. Now here's my minor one. But you know, I think it's. It's worth remembering that you know, the Value that there's several bits of the value that we bring with the Wolf language in my view. One is that we bring together curated libraries of all the world's algorithms so you know that they're good quality. But another is the automation we overlay on top and you've seen some of that in action already. And another is just making sure that they're usable. And there's two bits that one is the automation because sometimes we need to automate the skills and knowledge that you need because you can't be an expert on everything. So you might understand the concept of say machine learning or optimization, but you might not know the details. And the other is just to make sure that things join together, that the output of one function is useful as the input for another. So one minor detail that's been picked up in this constant search for ways to make things smoother is that in the engineering controller design world there are objects that are used for creating controllers called things like transfer functions and state space models. So there is that particular conceptualization of what is effectively simplified differential equations. And then you've got the maths world of differential equations, which is all writing down F prime of x equals whatever as equational representations. In our PD world we've been adding this high level representational world of physical objects, but the solvers are all dsolve or nd solvalue or dsol value. They're solvers. And so this world of, in this case, this is a state space model has been somewhat offered. You had to as a user figure out how to convert that to a system of equations so that you could solve it. And that's the kind of thing that should just work automatically. So now state space and transfer function models can just be passed straight into the differential equation solving commands. And getting an equational type solution out minor, you could do it yourself. But this is what you're paying us to do is to try and make sure these things are as smooth as possible. So it always pleases me when, when we stick to those principles and try and join things up. Right, different domain. How are we doing on time? Little behind. Let's talk about some of these things in the math space then. The first one is very much. And in fact I probably should have grouped these slightly differently about performance again in the numerical equation solving. We've had that since version one of Mathematica. I think N solve was in the very first version, so it goes back 30 years. But for very large systems there are faster algorithms that scale better. And on top of that when you're dealing with very large systems. So in this case I've only got one equation, but it's a very high order equation of x to the 12,000. This has 12,000 solutions. We don't always want every solution. Sometimes we need a solution or a few solutions. We don't necessarily need all 12,000. So the combination of new algorithms for the larger scale, either many thousands equations or equations of high order, together with the new option max roots means in this case I can get this particular answer 600 times faster. So really dramatic improvements if you're in that large scale system. Equation solving system space. A journey that we started in version 13.3 was the introduction of the finite field object. We've been able to do some finite field calculations for an awful long time, but it was a property of the function and there was only a few things that we could do. We never had an object by having an object. It's allowed us to automate now a lot of other functionality without having to create new functions. So dots linear solve. All of these matrix type operations now handle finite field objects. So these things are useful in cryptography, number theory. I think they're also used in control theory type problems. This is in simple terms, this is things modular arithmetic that if you add 2 to 11 in clock arithmetic, you don't get 13, you get 1 because you map round. So finite collections of things that have an arithmetic, but things like this matrix power of this collection of finite field objects to 100,000 is I didn't time that, but is kind of trivially fast to be able to compute. Whereas, you know, we didn't have the algorithms and the representation even to be able to add the algorithms before. Now this is sort of working across a whole bunch of new alpha operations and also across a whole collection of solvers. So for example, I can find a solution to this equation where the X, Y and Z are being elements from finite field 17 to the 3. And in a pretty short amount of time we have solutions to that. So really solid functionality that was built on the very basics that we added in the last release. Another one in the performance space is interval matrices. So this is where you have uncertainty on the values of the elements of the matrix. And again, without adding any new functions, all of these standard matrix operations now recognize interval matrices and operate much faster. So here's an example that I measured on my Mac to be 180 times faster. So really serious improvements. What this particular thing is doing is generating two random matrices that have had attached to them the actual guaranteed interval on the hundredth decimal place. And then I'm doing a simple operation here saying M times n and then the inverse of that matrix and I'm finding the biggest value, but I want to know what that biggest value is with its guaranteed uncertainty. So here's our answer for this particular random pairing, but we're guaranteeing that that answer is plus or minus 10 to the minus 94. Well, eight times 10 to the minus 94. And that, as I say now, that's fast. We can do these sort of reliability type computations where you need kind of guaranteed worst and best case scenarios. On linear algebra very, very fast. There's some new geometry. This is actually really probably part of the engineering story because we've had for a while in the graphics space bezier curve, B spline and B spline surface, but they were not recognized as geometric regions. And that's kind of important because if you're in the CAD design world, things like bezier curves were invented for describing the curved surfaces of cars. So if you want to take objects from a CAD world where you're using spline representations to describe objects, but then you want to pass them into, say, our PDE solver to simulate how they behave, then you don't want to have to kind of represent them approximately with some straight line representation and have to do that work itself. We can now import things that have these bezier representations and the whole geometry framework, which means all of the solvers and differential equation solvers that sit on top of geometry all now recognize these things as regions in the. Oh, I've misgrouped this. But in the polyhedron space, we've got 150 new polyhedra, always just adding to our data collections and lots of new classes. And you import and export of geometric formats in the graphs and network space. We've got a little bit of new stuff. Graph has grown a bit further, so there's another 80 classes. There's now 11 and a half thousand graphs in the database with many of these properties calculated across all of them. More general, and this is only cosmetic, but sometimes that can be important, that all of these graphs and all of the graphs you generated now have the ability to have them represented as layered graphs or layered graph 3D's. Now the algorithmically, they're kind of the same thing, but the results you get back will automatically assume that they're in a layered representation or to be rendered in 3D. And before you had to kind of call that thing manually rather than it being a property of the graph that was carried around. Another minor detail about joining things up is that for the whole kind of version 10 through to 13 release cycle, we built some really serious functionality for asymptotic solvers where you can't solve things with an exact equation. You don't want to have a numerical approximation, but the only way to do that is with things like infinite series. So here's an example where I'm solving some differential equation, but the only way to represent that exactly is as an infinite sum. Now that's very useful if you want to compute exactly and I can do transformations on this term by term over the infinite space quite easily. But if you want to actually now having generated this, make numerical approximations, then it's useful to be able to turn that into a finite space. So I can say truncate that sum and turn that from an infinite sum into a sum of five terms, which now resolves to an actual formula that we can then do things with like sample or plot quite easily. And it also opens up future automation where these infinite sums will be plottable because we'll be able to automatically call truncate sum when you try and plot them, for example, without getting caught up in the large number of infinite summations in order to generate the numbers. I'm probably going to skip other than to mention these things that we added line and surface and contour integration in the last release. But now we have the numeric approximate versions and we have some new special functions and convolution capabilities. Let's go into a much narrower domain now. Astronomy is a relatively recent arrival to take seriously and we had a lot of very high precision time and astronomical calculations just rounding out that space a little bit more. We now have really solid support for eclipses and moon phases. The eclipses is the deeper one where we have information on 70,000 solar eclipses, both past and future, 50 new properties. And some of those are quite kind of rich computation. So for example, if you happen to visit Wolfram HQ in a few months time, there is a solar eclipse passing I think right over our office. And here I'm taking just generating a a map of the path of that eclipse over the US but here are some of the properties that we can compute on that. So all kinds of things that are absolute things about the eclipse like when it starts and when it finishes, and maximum totality, but a lot of things that are also dependent on your viewpoint and or timestamp. So lots of computed properties and fixed properties of large numbers of solar eclipses. Similar kind of thing for moon phases, where you want to know what phase it will be and what from which viewpoints on the earth at what precise time, at any point in future and past. Now, stepping away from the fun computational stuff, external connectivity and system integration is always still a core part, particularly if you're building applications around Wolfram language. And there's a couple of slightly different stories to tell here. The first two are kind of opposite stories. Python we've had for some time the ability to do external evaluation of Python code. Things like in this case, I've got a library called Emojie emojize. I could probably write my own Wolfram language version of that. But why fetch the Python library and make a Wolfram language function that now calls that library. So my version is taking this thing and it spots the colon wolf and replaces it with the Wolf emoji by using this Python library in a Python engine as back end. Now, we've had that functionality for a while, but the problem was that the whole particularly Python world is the opposite of our approach, where we try to design and manage and organize things so that when you have Wolfram language, everything works, everything's compatible, there's no internal dependencies of have I got the right library of this? And that? The Python world is very agile because it doesn't adhere to that. But the downside is you've got to manage these things. And before this external evaluate, it could only use my Python install. And so if I have competing things that have different dependencies, like I've got a library that only runs in Python 2.7 and another library that only runs in Python 3.1, I've got to kind of manage those things, of fetching the right bits, checking that I've got the right dependencies, stopping conflicts. And now we, we have a way of encapsulating that in an automated way. So this command says Python evaluation. That's not new. We got the way of being able to set up Prologs so that all of the import done, the evaluator has the properties that says it's dependent on this particular version of this particular library and that it's going to be using this particular version of Python. When I run this the first time, it's quite slow. It fetches and installs and configures a Python environment that is matches these exact specifications. The second time I run it, it's all cached locally on my machine. But I can now run another command immediately on the next line that uses a completely different set of Python dependencies and the two are encapsulated and they should be platform independent. So I'm on a Mac, but if I. If you open this notebook on Windows, this should just work without you having to do anything except run this code. Now, our R integration, the kind of stats language is the opposite story because we up to now have provided R integration by downloading an R distribution that we've managed. And that's fine for convenience, but plenty of people have quite rightly said, well, I want to be able to call my setup of R, I don't want to have to reconfigure yours. And if there's a new version of R coming out, I want to get it immediately, not wait until you've picked up the managed version that you you provide. So you get some kind of potentially robustness from us having tested stuff, but you want the agility to be able to use any R distribution. So now R link can point to external R distributions so that you can have all of that management control yourself. And we also added some import exports, some new data formats that are R centric. RData and RDS are both kind of common formats for storing data in R, and we can now process those directly in the language. Also on the import story we have a couple of document formats. Obviously by far the more important one here is Microsoft Word format. So now I can import Docx files and fetch out the text of those so that we can join up with all of this natural language processing functionality that we have and LLM functionality for extracting knowledge from text. And. And it's become important to add DocX to the list alongside things like PDF and RTF and tech that we've supported for a long time. I mentioned, I guess already video import, so support for subtitle imports and export and more codecs. And there is also a quantum format called ibmmq, which is really an important part of the story for our quantum framework, which isn't built into the language, but it's a free packlet that we provide. At some point it probably will ship with Wolfram language automatically. But the Wolfram quantum framework allows you to describe quantum computing circuits and then simulate the behavior of them so you can design quantum algorithms that could run on a quantum computer, whether that's a present one or a future one. So really at the kind of research end of quantum computing, of not building the quantum computers themselves, but making sure that there are kind of quantum ready algorithms that can benefit from the potential quantum supremacy as these machines start to become commercially available. So we just want to be able to interchange these circuits and simulations with other quantum frameworks out there, of which there are a couple we already supported. I've forgotten what the there's an open source library that has a format that we supported already in IBM Queue is the one from IBM, so that's pretty much. Yep, I've filled my hour so that'll leave us 10 or 15 minutes for questions which I'll switch to the chat in a moment. Now's a great time to ask them if you haven't asked a question already. But let me just summarize here that there isn't a particular order here, but I put the machine learning and AI first just because it's kind of exciting, topical stuff. But you can see just reviewing this, that if you are working in particular domains or particular data types, we've tried to touch a lot of the main ones but also some of these things are just purely building out more infrastructure to make it faster, more robust and empower additional functionality that we're working on for future releases. So it's very much a something for everyone release. I think both in terms of domain and also some of these things are kind of advanced user type functions and some of them you will just benefit from without even noticing and other things that are sort of trying to make things simpler for beginner users. So I'm going to go over to have a look at the Q and A panel. I'm not seeing any questions at the moment, Jamie, if I'm missing any unanswered questions, do point me to the right place. I see there's some answered questions that have happened already. Maybe our team here has been too efficient on the.

Yeah, everybody's been very busy. Lots of good questions coming in. There's been a lot of excitement about Wolfram GPT of course, so lots of questions about that. I think there was a. There were a couple of comments coming in off the YouTube channel too, which we posted in the presenter chat on our. On our end here, but some excitement about new 14 features. I'm going to see if I need to read anything.

So that was some of your compliments saying thanks for the Onix import.

Right, Right, I see. So that was nice. But yeah, I think we've addressed anything else that's coming in. Of course, if people have continued or new open questions, go ahead and type them in. We'll give you a few seconds to do that here. But John, thank you for the really comprehensive overview and we do look forward to diving even deeper into some of These mathematical computation and image processing, audio video processing in upcoming sessions.

Great. So there is a question which is, is ChatGPT just working with Wolfram language or do other types of platforms? So there's a couple of things to say on that. One is that the idea of code synthesis is something that works across all of these. LLMs know all kinds of languages. I think in some ways we benefit disproportionately because our language has a large number of tokens. You know, if you learn Python, there's what, 180 tokens to learn and then you know the language, whereas in the wolfram language there's 5,000 to learn. So that having the LLM be able to synthesize code is actually a much bigger advantage and especially as realistically fewer people know Wolfram language. So being able to help you with those obscure bits gives assistance that other languages don't need. Plus our language being so much higher level means you can get quite a lot done in five or six lines of code, which LLMs are capable of doing. Whereas by the time you're getting them to write 50 lines of code or 100 lines of code, they break down into hallucinations. So we, we do pretty well out of that. And the idea of retrieval, retrieval augmented generation, where you have an LLM answer question but call on a backend to get answers, like computational answers or data answers, that's a very general concept that all of the big large language models can be used for. But one of the things we've done is to. With this idea of abstracting that, if I go back to. I don't know if I have an example doing that. Did we have an example of doing that in. No, these didn't have tools. But the idea we can say that there's a tool that will compute maths for you or will fetch a Wolfram Alpha answer. We've abstracted that out so that you just have to say a tool is this piece of Wolfram language code and that will do that retrieval augmented generation engineering for you automatically. So you don't have to set up the. How do you call a tool and how do the tokens work to say when the tool is being called and when it stops? That just works by adding here. I guess I would go into this and say tools go to LLM tool of and I can't remember what the parameters are, but you describe the Wolfram language code and even then when I swap between the different models like Claude or OpenAI, that that will just work, it'll change the way that those tools work. So it not there's nothing exclusive. And in fact our strategy is to not be exclusive at all. We're trying to be agnostic to the back end so that, you know, in a year there might be a hundred of these LLMs out there, including all the local ones that like, like llama files that have come online will all just plug into this framework. And we try not to be too tied to anyone. Yeah. So I don't know if this cement is a criticism or whether it's a pure question. What does it mean to increase the compilable functions by 3 or 4? The idea of let me do this lesson for those who don't have a compiler is that if I have a function, say the typical way you might write in Wolfram language as a pure function would be to say a function that takes an argument and returns X squared and we can call that on a number and it works. What the compiler does is allow us to do that in a labeled way so we can say typed that comma and we'll give it a type of say, say real 64. And that hasn't changed anything apart from the fact it's not balancing. That still does the same thing as before, but now we can make a second version of that, which is compile. If I've got the syntax right here, first time is a little bit slow as it loads the compiler, but hopefully if I've got that right, we now get a version of that that does the same thing, but is now written in compiled code that is optimized for the CPU of my Mac and is running as a dll. So it's super, super fast. So in this example, it knew power and it knew Real 64 were the only things it needed to know. So at the moment we've got most of the programming and arithmetic type things in the compiler built out. It's probably going to be a long time before I can put dsolve in there and say I want a compiled version of differential equation solving. That may never happen, but each release we're adding more and more things before you get to the point where it says, sorry, that's not compilable. Now we already have ways to fix that anyway, where you can say, okay, here's a function like hypergeometric pfq. I don't know if that's compilable or not. Probably not if you hit that. Cool. Back to the Wolfram language to do that bit of it, do the rest in compiled code. So it's not the end of the story, but we're just trying to make it so more and more of the language can be compiled and made fast. Before you get into bits where you have to juggle do I use this function or do I have to write it in lower level code? And we don't want you to have to write low level code if you can help it. Okay. I'm afraid I don't know the answer to Net Nest list operator getting added I guess that's been something that's come up in the design reviews. Maybe we can try and find out for you outside of that outside of the live stream or if we have somebody talking about the in the follow up webinars, Jamie can say whether we have one from the do we have somebody from the machine learning team in one of the follow up webinars?

We do.

We will. Okay, so I encourage you to return for that and repose that question and they will be the ones who know the answer to that one. Will there be a freeish LLM specification for Wolfram language? Don't need leading edge. Oh sorry. Ll specific for Wolfram language. So while we're running things in at least for foreseeable, while we're running these things through people like OpenAI or then you know, there's a cost of running those things and they're not free. What we are getting coming on stream is these local large language models. Now our functionality of abstracting them hasn't covered those yet. There's some code you can see on in fact I posted something just yesterday on connecting Llama file which already is out of date because the download link I had is gone and somebody's posted a fresh one that allows you to run a local LLM and call out from the Wolfram language. What we want is of course all of this functionality to seamlessly use that. In which case you could have code generation that's entirely local on your machine. No privacy issues, but also no paying cloud service fees for anything. Whether they will up be up to the job of writing decent Wolfram language code is yet to be seen. So you may find that they can do very basic things for free, but you're always going to need some kind of web service to be able to do the very best. I have to say though that when I from my experience when I've been using OpenAI in chat mode, answering questions I'm personally typing it is as good as free that a few dollars just goes incredibly far in terms of credits because any one question is taking a Fraction of a cent or one or two cents for a big question. These things only really get expensive when you start using them as computational machinery and you say, okay, I want to do some LLM based operation on every record in my huge database. Then suddenly that fraction of a penny adds up to thousands of dollars in a single run quite quickly if you've got a large database. Any further questions? I think we are almost out of time as well, so if somebody is quick. Oh, sorry, I can see I have not scrolled the question panel and there are more questions. Sorry, I. Let me run through some of these quite quickly. Is it possible to take the Eclipse map and wrap it onto Sphere? I think you can actually provide projections for the Eclipse map, so you might actually be able to put it. Well, that would allow you to get the right projection to then map onto Sphere. I don't think you can put it straight on the sphere, but yeah, that should be. Should be easy to do. So arbitrary dimensional symbolic vector calculus functionality to be added. I was in a early design review meeting where that was exactly getting discussed. So there is a plan to add it, I believe, but I have no timeline for symbolic tensors. It's only something that a lot of people would like. Is there a link to the autorag functions? If. If you have a look. If you go online here and go to the Wolfram language documentation and look up LLM tool that will give you the syntax of how you set up tools. So this is a bit small on screen, but it's go to reference.wolfram.com and look up LLM tool to find that. And the link to the. To the. I thought I'd put in a link to the repository. There we go. So there is the link to the LLM tool repository. As I say, there's nothing there yet. We're hoping that everyone's going to contribute and that tool will grow. It's got a dozen things in this at the moment, but that's the new repository for submitting rag type Wolfram language powered tools to. Is there any difference between using the Wolfman language plugin in ChatGPT and using ChatGPT in the in mathematical environment? A couple of things to say. One is that plugins are sort of going away. If you Google Wolfram GPT and there's a page on our site, you'll see that it's being replaced with the idea that you have kind of custom GPTs that effectively have the plugin already built into them and that also allows us to do fine tuning on top when you call from the LLM functionality within the Wolfram language, then you have much more detailed control over what that tool does. So, approximately speaking, if I do LLM synthesize with GPT4 as the back end and LLM tool goes to Wolfram Evaluator comma Wolframa, Alpha Evaluator or whatever it's called. If you add those two tools in as tools into that command, that's roughly the same thing. But you can do a lot more through the Wolfram language than you can by just using the interfaces provided by ChatGPT.

John, I think we might need to wrap it up there, but I got one request I saw here from James is if we could include your chat GPT prompts, would that be possible to save those?

And we oh, the yes, the ones I did off in the demo. Yes, I will.