Mathematical Computation in Version 14.1

Hi everyone. I'm Jamie Peterson, Director of Wolfram U, and it's my pleasure to welcome you to the second session in our new in 14.1 webinar series. Last week we enjoyed an overview presentation by John McCloon, and the recording from that session is linked right here from the landing page if you wish to revisit it or if you missed it last week. Today I'm pleased to welcome members of our mathematical computation team led by Devendra Kapadia. Let me get those presenters on the screen for you. They'll be talking to us about the latest mathematical functionality in the new version 14.1 of Mathematica and Wolfram language. Devendra will open with his overview presentation on the mathematical computation, followed by Itay Segev presenting on symbolic arrays and their calculus. Aram Mansalian will speak about stability analysis of dynamical systems, and Oliver Rubin Koenig will share about advances in in PDE modeling. As you can see, we have a full schedule ahead of us, so I'll just say that version 14.1 brings an impressive roster of long requested features and additions to the language. You can read about the mathematical computation topics and lots more here in Stephen Wolfram's release announcement. To try the examples from today's webinar, you'll want to access version 14.1 and we'll share a free trial offer so you can get started right right away. We're also going to ask a poll question to ask everyone in the webinar audience if you've already upgraded. We have a YouTube livestream audience as well and for those of you on YouTube, feel free to type your responses, comments and any questions in the chat. We have Wolfram webinar and technical staff joining us behind the scenes today to help us coordinate Q and A between the webinar and the live stream. So I encourage you to type your questions as we go along. Our staff will answer what we can and typed responses to you, and we'll save some questions for the team to address at the end of all of today's presentations. So let's take a look at that poll. I want to see what the responses look like. Great. Most have already upgraded, which is fantastic, and the rest of you are in progress it looks like, so we hope you have lots of incentive to get that latest version after looking at this latest functionality. And of course the trial is a way to access the new release if you're waiting to get that new version from your site. So I want to just say there's a download link there in that green highlighted area in our chat. That's where you can find all of the presentation notebooks from all the webinars. We'll be adding notebooks each week as we continue the series and I hope you plan to join us at the upcoming Wednesday webinars. Thanks for your attention. Without further delay, I'll hand things over to Devendra we with our overview presentation.

Hello everyone and welcome to this webinar on mathematical computation version 14.1. My name is Devendra Kapadia and I'm the manager of Mathematical Computation at Wolfram. It is a great pleasure to speak to you about the new release today. Now version 14.1 includes several new major and interesting features in the area of macro computations. We have not just one talk, but four talks Today there's this talk, an overview talk by myself, and then there'll be another talk on Symbolic arrays and their calculus by Itai Segev, a third talk on stability analysis of Dynamical systems by Aram Manacelian, and finally a talk on Advanced in PD Modeling by Oliver Ruben Koenig. So I hope that together these talks will give you a pretty good idea about the new release. Now one point about these live webinars is that they give you an opportunity to communicate with us about how you feel about the new release. Any suggestions you have. So please feel free to use occasion to communicate with us and it'll be a great pleasure to answer your questions. So let me now begin by giving you a plan for my own talk. So in this talk I'll discuss new development rate to a few areas. I'll bring symbolic arrays which we have talked about for a long time. We say two and a half, three decades almost, but never got around doing them correctly. And I think this time we've got them right. Next I'll talk about stability analysis, a very beautiful topic going back to Poncari and give you some insight into the new feature for differential and difference equations. Now we've been doing lots of special functions over the years, even things like appel functions and bilateral hypogematic functions. Very advanced features. But in this release we kind of go back to high school trigonometry and we have new functions for doing trigonometry using degrees rather than radians. And it turns out that even with that kind of a simple looking task, there is quite a bit of work to do to integrate these functions into the system. One of the most popular functions in calculus is dsolve for solving differential equations, and traditionally you had to give us Three arguments. The first argument is the equation or equations. Second argument is the depend variable and the third argument is the independent variable. But in this release we have now made things simple and you can use DSOLVE with just a single argument, the first argument, and we'll figure out the rest for you. So that's a pretty convenient thing for people who are just Starting to use DSolve for the first time. We also have some interesting development. Discrete calculus, two new functions for convolution and rate to the binomial functions. So I'll talk about those. And finally I'll give just one example of PD modeling. But I should say straight away that this is a big area of the system. It's not just that it's actually an industry, it's one where we put a lot of effort in in the last few years. And I hope to show you the power of this functionality in 14.1. So let me then begin with array variables, symbolic arrays. So version 14.1 adds support for defining symbolic vector, matrix and array variables. So for example, let's say you want to define a symbolic vector of length three, you can do it this way. You can say V equal to Vector symbol V comma 3 and you get that this very nicely typeset output. And the point about these symbolic vectors is that they are non threadable. What that means is that they don't participate in threading. And what that means is, suppose you have V the vector symbol and W, which is just some other variable, and you add them to the list 1, comma 2, comma 3. Then the W goes inside the list, while V stays out, it does not participate. That's critical for making things work symbolically. And that's one of the reasons for having these dedicated vector matrix and array symbols. So in fact going into matrix symbols. So let's say over here we can define a symbolic Matrix of Order 2, two by two, you can check the dimensions over here, and then you can even solve an algebraic equation involving this matrix M. You can see things are being done purely symbolically. That's really elegant, particularly if we're working with very length vectors or very high order matrix, etc. So the fact that you can use this is really, really convenient. And finally, arrays. So you can define symbolic arrays. So in this case symbolic array dimensions 2 to 3 and you can use it for example, in an optimization problem. This new array dot function is just like a dot product, but a bit more general. Okay, so with those array variables in place, we still need some special array constructors. So for example, you need a kind of symbolic zero array. So symbolic zeros array represents an array of zeros. And so for example, if you take a vector and subtract it from itself, then you get back a zeros array in this case, okay, so the point is that you, you need the zero, but you also need ones. So symbolic ones array represents array of ones. So that's a symbolic ones array over here a vector of length three. And finally we also need an identity array. So you can see symbolic anti array of order three and you get back in this case just an anti Matrix of Order 3. We also have something called a symbolic delta product array, which is a kind of chronicle delta array, but I won't go into much detail about that. So once we have variables in the constructors, we can actually do some calculus. So let's talk about array derivatives. So in earlier versions you could do some kind of array calculus. You could compute array derivatives in this way over here. So you could have your scalar function over here, and that's kind of a vector and you can compute the derivative like over here. But that's not very convenient if you have very large length vectors, etc. So in version 14.1, such derivatives can compute it using the new symbolic representations. So for example, let's say you have a vector symbol of length two, for example, and then you compute the derivative of dot product, you get back twice the vector. And if you come to the derivative of vector with respect itself, you get in this case the energy matrix of order 2. If you think about all the partial derivatives and of course you've got a constant vector with respect to V, then you get back zeros array. Now the nice thing, we've gone beyond that. And so for example you can do the derivative of the mean of a vector symbolically and get back a symbolic onez divided by n. So it's all very consistent and clean so far. But the deep part comes when you go to matrix derivatives. So for example, if you have a matrix symbol like in this case order n and you ask for delta trace, of course you get back the symbolic entry array over here. But the more interesting example over here is that for debt we get back an educate. That's a bit non intuitive, at least even to me. So I feel that there's some learning to do, getting used to, but the rewards will be immense. And we also other examples, documentation for linear sol etc do look at them. So that's one major feature. Another major feature is stability analysis. So in earlier versions you could Compute the exact solution for a system of OD's using DSolve or a numerical one using ND. Solve or asymptotic solutions using asymptotic dissolve value. Now what version 14.1 does it goes step further and and allows you to perform a stability analysis of such systems. So for example, here you have a nonlinear first order OD and to get some simple solutions just set this derivative equal to 0 and you see x equal to 1 or x equal to minus 1 are simple so called stationary or fixed point solutions. So here's the vector field for the equation. And see over here you have the negative one and the one as constant solutions, but they are not quite symmetrical. Solutions seem to flow away from the one and towards the negative one solution. So in some sense these two fixed points, they might call them, are different in nature. And to see that a bit more clearly, you can use a new function, defixed points to figure out the fixed points. And then you can use these stability conditions to examine what happens at those fixed points. So the negative one, comma true means that you actually have stability at minus one and the false way means that you have unstable behavior at one. And as an example of this new functionality, I'll take up a very famous example, the Lorenz equations, which are a system of three nonlinear OD's with three parameters. And depending upon these parameter values you might get a chaotic solution or a well behaved solution. So with these particular parameter values and the Lorenz equations given over here, in fact destability says that you have three fixed points and they are all unstable. So these are the conditions give you some information over here you can then use ndsolve and actually plot the solution and get this very famous Lorenz attractor. So for pretty difficult nonlinear systems, you can figure out what the stability conditions are for that system. Okay, so onto high school trigonometry. So we have in version 14.1 12 new degree trigonometric functions. They are called sine degrees, cause D etc. Which means you work in degrees directly rather than radius. Now we could do in some sense releases, but it wasn't quite enough for what we were trying to do. So you can say sine degrees of 45, that's in degrees and you get back one over square root of two. You can plot the functions, they look just the same as always, except that you're now working in degrees. Now the point is that these new functions are quite deeply integrated in the calculus and algebra framework. So some examples for that you can ask for the function period of sine degrees and you get back 360, which is of course correct. You can solve a trigonometric inequality like over here and the plot tells you that the answer looks correct. Or you can do some other things. You can expand a multiple integral expression like over here using trick expand and then you go the other way using trig reduce and get back to where you start from. So these pretty old classical algebra trig functions have been modified to accommodate the new functions. And finally you can compute a derivative of cos degrees. You get back almost negative sign, but with this fact over here, which tells you that really one ought to work on in radians if you want to do calculus. And documentation has got other examples which are suitable for using in high school classes. So these trigdegree functions should be really useful to our younger users and to ourselves when we build courses on them. Okay, so onto dsolve, a popular function. So in version 14.0 you had to specify three arguments. The equation, the depend variable and independent variable. In 14.1 we got rid of the last two if you wish to, and you can use the equation over here and you get back the same solution as you did in 14.0. This should work in a very large fraction of the examples, except where the second or third argument is saying something special about the equations. So you can go step further and just say Y prime equal to y and we invent a variable and return the solution for you. You can solve an initial value problem like over here with only one argument and you get back a solution. You can plot it so the workflow is just what it was. It's just become a lot more convenient. Or you can even solve a partial differential equation, in this case the wave equation, without any difficulty. So you might ask, where did the idea come from? Well, it came from our experience with Wolfram Alpha, where that's the way people input things. It's almost free form. And we have done our best to put in DSolve. It's kind of experimental, but I think it should work really well in many cases. Okay, so from DSolve, I now go on to discrete calculus. So discrete calculus, something we installed in version 7.0 and then we kind of forgot about it. Okay, in the sense that we didn't do any significant updates, but we, we do have a significant update for this functionality. In version 14.1 we have improved the series coefficient other functions, but we also have two new functions, Unilateral discrete convol and Pascal binomial. So the first function is really for computing the causal convolution of sequences. And that's often what people want when they ask us to do a discrete convolution. So we have discrete convolve and now we have the unilateral version of that. So here are two unit steps, sequences. You run the convolution on them, get back a piecewise function, and really what's happening underneath is that they're being convolved using a sum computation, the typical convolution sum. And if you do a discrete plot, you see that in fact there is some smoothing out effect even in this rather simple situation. The other new function is Pascal binomial. So the point is, we have had binomial for a long, long time. And traditionally binomial of N comma N has always written one that's critical to our symbolic functionality. And one might say, what's wrong with that? Well, the difficulty is when you have negative values of n. So Professor Don Knuth, a very distinguished professor in this area, reminded us that the binomial as we had, it didn't quite obey the Pascal entity for all integers. So we have Pascal binomial, which is a bit more careful about the auto expansion and does things right in Professor Knut's view. And I kind of agree with him. If you look at this figure over here, you have this symmetric kind of binomial over here and Pascal and kind of binomial over here. And what we've done is to let both groups of users have their say in the new release. And finally I go into PD modeling, a very beautiful, powerful area. So we have several new features of PD modeling in the new release. And in fact we have new functions for working with electric currents and Von Miles stress particular. So here is an example from the documentation, which is beautiful, I recommend you look at it. So you want to model a tungsten wire, you specify the various parameters, that's the PD components setup. Specify some parameter values. Here is the simulation domain, the wire itself. And then you need some boundary conditions to get things going. Solve the equation using nd, solve value and compute the current density. And you get back this beautiful plot of the wire and how it behaves at all these kind of corners. So if you want to do really fine grained PD modeling accurately, then the FEM approach is what you need. And I think that this is a wonderful area for functionality. It needs to be even better known than what it is right now. So with that example I will conclude my talk. Thank you very all very much for coming over here. We do appreciate your support for mathematical computation, and because we enjoy it so much, we continue to do it. And I'd also like to thank the team members who put in all the effort in the last few months and the Wolfram you team, which always gives us this wonderful opportunity to present our work after each release. So thank you and I'll stop over here.

Hello everybody. Thank you for coming to this talk and thank you Devendra for that introduction. I'll be giving a somewhat more in depth look at the symbolic arrays and their calculus. So I'll start off with a little bit of history, which is definitely not a comprehensive history, but it has sort of the key points I need for the story I'll be telling today about vector variables in the Wolfram language. So in version 9 we added support for declaring symbols as vectors, matrices and arrays. This used the assumptions mechanisms and was very focused on algebra and symmetry. In version 11.1 we added support to D, Grad, Div and Laplacian for the ability to recognize inactive table as a valid variable and allowing some tensorial derivative computations to be done. Basically, substrate and index and certain related things were recognized as representing tensor components. In various versions of 12 and 13, we added support to a bunch of functions to understand variables declared as vectors and matrices using the version 9 syntax and to just give three prominent examples. D solve linear optimization and convex optimization all did this. I could have easily given probably 20 examples if I wanted to. So what's new in 14.1? In 14.1 symbolic arrays are promoted to a first class object. That means they're self contained, they have the new non threadable attribute which the vendor mentioned. But I'll go into a little bit more detail and this can be used with new or old methods. So if you want to continue using the assumptions mechanism, you can and just add the non threadable attribute to your own variables. That that will work and that's a good way to work and this builds on earlier efforts. It's not just something coming whole cloth like Athena out of Zeus's head. So let me illustrate this history with just a couple of salient examples. So let's do a version 9 example. In version 9 we could declare variables to be arrays. In this case I'm going to declare A and S to be two matrices. S is A is an element of the space of n by n matrices with real components and it's symmetric in its two levels, whereas A is also an n by n matrix, but it's anti symmetric and so I'll evaluate that and that just creates some assumptions that I can later use. And now let's canonicalize the total contraction of the tensor products of the matrices. If you don't speak tensor contract well then this is the trace of the product of S and A. And if we do that, we get zero. Why is it zero? Well, one symmetric, the other is anti symmetric. If we take the transpose, then this scalar quantity is supposed to be the equal to its negative and that means it's zero. Great. So then in 11.1 we started, we're working on derivatives. So here's an example. We have the squared norm here. What's the squared norm of a vector in terms of components? Well, it's the sum of the xi From I equals 1 to n. And here I've used a subscript to represent the components. And then I'm going to take the gradient with respect to xj and it's an inactive table, meaning it's almost a list, right? It's a component of a list which goes from one to n. That's what the j comma n here. So if I do that, I get this table and I get a component here. If we did the sum, then this would be 2xj. And so setting aside the question of exactly when we do perform various simplifications, we have here, and this is again a table, right? Because the gradient of a scalar is a vector. So this has n components. And we can make this explicit by substituting in n goes to 3 and activating the table. And lo and behold, we get 2x sub 1 and 2 and so forth. So how does this now look in version 14.1? Well, the first example looks pretty darn similar. Rather than saying S is an element of the space of matrices, we just create a matrix symbol with the name S. Then the remaining arguments are just the arguments to matrices. So you see here, instead of S element matrices of these three things, I say matrix symbol. I give the matrix a name. That name is used in the typesetting and we see the little back and forth arrow to indicate that it's a matrix. On hover, there's a tool tip that says this is a matrix over the reals of n by n and it has a symmetry. Similarly, we can create an anti symmetric matrix using matrix symbol. And there we go. It looks much the same, only it's anti symmetric in the last two slots and we do the exact same input we did before and we get zero. Now, adapting the 11.1 example requires a Little bit more work. I mean, the first obvious step is we are going to represent the whole thing using a vector symbol. So again, saying V is an element of vectors, we just create a vector symbol named V in dimension n over the reals. Now we're going to have to represent the squared norm rather than in components using this vector symbol. Well, that's pretty simple. That's just v dot V. And now we can compute the gradient of that with respect to v. And lo and behold we get 2V. And again that's in dimension n. So there's some basic examples. So let's delve a little bit into the details. So we have vector symbol, matrix symbol and array symbol. These take a name and optionally the arguments to the existing vectors, matrices and arrays functions. So here's a three dimensional vector. I could also represent a three dimensional vector using array symbol. That little one over it tells you that it's a rank one array. So this is another valid representation of an array of a vector. And so, you know, these both represent the three dimensional vector. One is explicitly a vector, hence the little arrow. The other is a rank one array, hence the little one. Here's a three by four matrix over the integers. Again we get the little back and forth arrow and when I hover over it we see z to the 3 by 4 telling us that it's over integers and it's space. Here's a more complicated example. And now you'll be able to tell that my background is in the theory of relativity, because I'm going to create an array with the symmetries of the Riemann curvature tensor. So this looks kind of complicated, but if we just unpack it, we have something called R. It has four, four levels, all of length n and real entries. And then if we swap the first two levels we get a minus sign. If we swap the last two levels, we get a minus sign. And if we swap the first pair with the last pair, it's symmetric, hence the plus one here. So all of these functions, as well as the new special array, special symbolic arrays, have the non threadable attribute. This attribute disables the automatic threading behavior. We say that a listable function threads automatically over lists, but there are times when you don't want that to happen actually. Because imagine you're going to be adding a symbolic vector to an explicit one. In this situation you just want it to just sit there because you can't simplify that at all as long as we don't know what V is. Now if we had just the normal symbol V rather than a vector symbol here and we added it to the list 1, 2, 3 we'd get right, we'd have the automatic threading over plus and we'd get 1 plus V2 plus V3V. That's clearly the wrong answer if V is representing a vector. And so this new non threadable attribute allows us to get around this. And like I said, you can set this on your own symbols if you want to use the assumptions based mechanism or for whatever other purpose. So two special symbolic arrays are symbolic ones array and symbolic zeros array. As the name suggests, they represent arrays of all zeros and all ones. If the dimensions are concrete, I.e. positive integers rather than symbols, then you can convert them to a normal array using normal. So here's a Matrix who's a two by three matrix whose entries are all ones. Mock one's array of the list 2, 3. Since that's a concrete dimension, I can convert that to a normal matrix and use matrix form. And lo and behold I get a matrix whose entries are all one. Similarly, if we take our rank four array and contract the two indices well now we're going to get a matrix of zeros out of that. And again, right, it's the, it's zero because it's anti symmetric in those two in those two slots. So when I contract I go down from rank four to rank two and it's zero n by n. There is a special, there's a third symbolic array called identity array which represents the identity operator on arrays. I think this is clarified best by examples. Symbolic identity array is the identity operator on two vectors, meaning it's the two by two identity matrix. So if I convert that to its explicit form, I get 1001, I can create the identity operator on two by three matrices. That's going to be a rank four matrix. So we have a two by three matrix of two by three matrices and if we look at the dimensions of that, it confirms that interpretation. You get double the rank of what you see in the list because it's the identity array on those arrays. There's a as like the vendor I'm going to refer just refer you to the documentation for symbolic Delta product array or as I like to call it, the aptly named symbolic array not appearing in this talk. It's, it's just a little bit off the beaten path and a bit more complicated. So I think it's best to just refer you to the documentation if you want to see those details. So with all those preliminaries we can talk about differential calculus. So D can now differentiate with respect to symbolic array variables. For symbolic vectors, this is the familiar gradient. And grad can be used in the same manner for higher rank arrays. This is a generalized gradient. And in general, if you differentiate a rank of rake an array of rank k with respect to an array of rank L that you'll get an answer which has rank k plus l. So I'm going to clear out the assumptions I created earlier and just create a vector matrix and array for use. And I'll start with the simplest possible example. You're going to differentiate a scalar constant with respect to a vector. You get a zero vector out. We can do the same computation with grad. Now if you differentiate scalar with respect to a matrix, you get the zero matrix out. If now I'm going to differentiate a constant array, right? This is the array of all ones and we get a rank three array. Because I'm differentiating with respect to a matrix, we get the K from the symbolic ones array and then the two N's from M. Now the derivative of an array variable with respect to itself is always the identity array, but it's the identity array of the correct shape. So let's differentiate a quadratic form v m v and we get M v plus v dot m. If we did that with a scalar value, sorry, with a vector valued quadratic form, we get essentially the same thing, only we express it using an explicit transpose. Now let's differentiate a dot Product m.a.v with respect to a and we get m dot and then we get this funny looking T colon thing. So this t colon means two argument transpose and this two. Here is a new syntax for transpose which basically means slide everything over by two spaces. I'll let you read the documentation for all the details. But basically we need to move the slots over so we are dotting the correct levels. But basically we got A and then the M and V stuck around. Just to confirm what I said earlier, the input has rank 2 because I'm dotting a rank 3 array with a matrix on one side and a vector on the other side differentiating with respect to a rank 3 array. And the result has rank 5 and 2 plus 3 still equals 5. So many array functions have built in rules, so there's adjugate and of course there's an appropriate chain rule. So here I've created a matrix by dotting V into A, and I get the same sort of derivative as I got before dotted a particular chain Rule type thing. And this array dot means rather than just contracting, dotting the last slot of the first vector into the first slot of the second vector, well, we're going to dot the last two levels into the first two levels and I could have three, where I do three dots, three slots dotted into the next three slots, etc. Higher derivatives are supported. So here's the second derivative of V dot V, that's twice the identity matrix, right? We got two V. And then we're taking the derivative of V with respect to V&DIV and Laplacian are supported. So the divergence of a vector in dimension N is N and the Laplacian of the squared norm is 2n. So let me give you just a little bit about where we are and where we're going. In version 14.1 we've introduced these symbolic objects. These allow array symbols to be used in many more functions. And the key thing about making it self contained as opposed to relying on assumptions mechanism is that there are a lot of functions like + that don't know about assumptions. If we need, if we were going to make it work in general, we sort of needed to make it self contained. We have new support in D for dealing with these objects. And we can derive simple formulas and substitute in specific instances can also prove various simple identities. Right, I derived right, we got the zeros out when you contracted antisymmetric things. And there are applications to optimization, machine learning, basically everything you, you know, that sort of you get from derivatives. But there's still more to come. And as just a little teaser, which of these two proposed identities is correct? If either. Well, if you are able to instantly tell the answer, then you're smarter than I am. I actually had to work this out. This first thing is actually true, and the second one is actually false, even though it looks more likely to be true. But in fact, if you work through it carefully, this term is not actually even well defined if the matrix A is not square. So what's the point of this example? Well, there's a lot of ways to express a single expression and that means proving or deriving things that look like traditional textbook derivations is really hard. You need a good way to canonicalize these expressions and that's something we're actively being worked on to fact in this morning's development build. We should be able to actually prove that these formulas are either true or false. Unfortunately I didn't have a chance to test that and incorporate it into my talk before it started. But that's something to look forward to in our next release. And with that I thank you for your attention and I will allow Aram to make his presentation.

Hello, I'm Aram Mana Selina from Mathematical Computations Team and today during this webinar I will speak about one of the new features of version 14.1 about stability analysis of dynamical systems. My talk will be organized as follows. At first I will give a brief introduction about the stability or instability of dynamical systems, and next I will speak about four new system functions implemented in version 14.0, which makes it really very easy to do stability analysis in Wolfram Mathematica. During the next part of my talk I will speak about how it works. Here I will show you the main methods and algorithms used in stability analysis for different types of dynamical systems, such as continuous or discrete, linear and nonlinear systems. And finally, during the last part of my talk I will speak about applications of stability analysis. So, let's start. The history of stability analysis is starting from the works of Newton, Euler and Lagrange, when we started to use differential equations to describe some physical systems. But the stability theory became a really hot research topic after 1963 when Edward Lorentz, mathematician and meteorologist, wrote down his famous system of three nonlinear differential equations which describe the airflow process between warm and cold layers of Earth's atmosphere. Here we can see the system Lorentz equation. We have three dynamical variables here, X, Y and z. Also we have three parameters, sigma, R and B. And if you try to solve this system numerically for some values of parameters and also for some initial conditions, you will see that the solutions are very unstable and the instability here means that any small change of initial conditions can cause huge changes in this solution. And there is an example about this issue. If some point of the planet butterfly moves his wings that can cause a tornado in some other part of the planet. Here you can see plot of one of the solutions of Lorentz equations or so called Lorentz attractors. We have two attractors here and the centers of these attractors are so called fixed points of the system and both of them are unstable. In this case a mathematical pendulum is another simple example which can be used for demonstration of stability and instability of the system. As you know pendulum has two stationary or equilibrium state, the first one when it is in down position and second one when it is in up position and both these states are corresponding to points in phase space, so called fixed points of the system and the nature of these two fixed points are completely different. For the first case, the fixed point is stable because if you slightly move pendulum from this state, it will start to oscillate and eventually will return to stationary state due to damping effect. But in second case, if slightly move pendulum from stationary state, it will never return to wet state again by himself. So the main objective of stability theory is to find all the fixed points of dynamical systems and also to analyze their stability. Why we need this? Because the stability analysis allows us to get a lot of information about the behavior of the solutions of the dynamical system without actually solving the system. And I want to announce here that in version 14.1 we have implemented four new system functions which allows us to do stability analysis in Wolfram Mathematica. And these four functions are defixed points. The stability conditions are fixed points are stability conditions. D fixed points returns all the fixed points of continuous time dynamical systems with differential equations. And this stability conditions analyze the stability of all fixed points. Similarly, R fixed points and r stability conditions do the same for discrete time dynamical systems with regurgit equation. As an example, let's try to find fixed points of following first order non differential equation, we can write d fixed points equation, dependent variable, independent variable or time in this case. And that's it. Here we have two fixed points minus three and zero, and we can analyze the stability of the point using this stability conditions function. And we see here that minus three is stable point and zero is unstable. And we can use stream plot function to visualize the stability in case. If we have parameters in the equation, this stability conditions returns stability conditions for each fixed point. As an example, in this case we can see that 0 is a fixed point which is stable only if real part of parameter A is is negative. Also we can use assumptions option to specify the types and values of parameters. As an example, here we specify that parameter A is negative. As a result we get that point zero is stable. Now let's discuss how it works and I want to start my discussion from continuous linear systems. If we have a differential equation of the form x prime equal to F, then the fixed point is a solution of the equation FTX equals equal to 0. For system of first order equations X1 prime equal to F1, X2 prime equal to F2, etc. The fixed points are solutions of the equations F1 equal to 0, F2 equal to 0, etc. Higher order equations are reduced to system of first order equations. As an example, let's consider following simple od x prime t equal to a xt. In this case, the fixed point is A solution on the equation ax equal to zero, which is x equal to zero. The solution of the differential equation is proportional to exponent A t function. So the solution will be stable only if real part of the parameter A is negative. Otherwise the solution will tend to infinity with increase of time. And this stability conditions returns the same result. As a next example, let's consider a simple system of two linear parsito rotis and we have also two parameters here, A and B. The fixed point of this system are solution following equations and the solution is x equal to 0, y equal to 0 and d fixed points returns the same result. A linear system of first order differential equations is stable only if all eigenvalues of its coefficient matrix have negative real parts. In this case the coefficient matrix is M and we have following expression for its eigenvalues. So these stability conditions will return following condition or stability for this fixed point. Now we can plot parameter region for which the system is stable using region plot function. And we can use stream plot function to visualize stability of the system for various values of parameters A and B. Here in the first case we have a stable spiraling point. In second case we have unstable spiraling point. And in fourth case we have a saddle point. As the next example, let's consider larger systems. In this case we have a 10 by 10 linear system with random constant coefficients. We can use random integer function to generate the system. And for this system this stability condition will return one fixed point with 10 coordinates. The fixed point is unstable, but the code is really very fast. We spent only 0.03 seconds to analyze the stability for 10 by 10 system. And as a next example, let's consider a higher order differential equation. In this case we have further order equation. So in order to get fixed points we have to reduce the order to get a system of first order equations. We can easily do that by introducing new variables y1 equal to y prime and y2 equal to y1 prime. As a result, we will get following system of free first order equations and the fixed point will be the solution of following system and the solution is 1/2 00 and defixed points returns the same result here. Now if we use the coordinates of fixed points as initial conditions for higher order equation, we will get a constant solution. If you start from the fixed point, you stay in a fixed point. And this stability conditions in this case will show that the point is stable. For the case of nonlinear differential equations, the number of fixed points can be more than one, and in this case we cannot speak about global stability of the system. Instead, we can speak about local stability near each fixed point. A nonlinear first order differential equation will be stable near one of its fixed points if the linearized version of the equation near the fixed point is stable. And here is an example of a first order nonlinear differential equation. And this equation has two fixed points. Now we can linearize the equation near first fixed point and we will get linear equation with negative coefficient here, which means that this equation is stable near the first fixed point. Now we can linearize the system near second fixed point. And in this case we got an equation with positive coefficient here, which means that the equation is unstable near second fixed point. And we can use this stability condition directly with nonlinear equation to get the same result. And here is the stream plot of the system. As a next example, let's consider system of two nonlinear differential equations. This system has four fixed points and we can use these stability conditions to analyze the stability near all fixed points. And we see that two fixed points are stable and the other two are unstable. And here is stream plot which visualizes the stability here red points are stable fixed points and blue points are unstable fixed points. And as the last example, let's consider this nice system of two nonlinear differential equations which has only one fixed point at origin, which is unstable. But we can see that all tractories of the system are tending to this circle. Now let's discuss discrete systems. If we have a recurrence equation of the form an 1 equal to fnan, then the fixed point will be a solution of the equation FNA equal to a. For a system of first order recurrence equations of this form, the fixed point will be the solution of the equations f1 equal to a1, f2 equal to a2, etc. And higher order equations again are reduced to a system of first order equations. And here are few examples. But first let's consider recursion yn1 equal to ayn. This equation has 1 fixed point 0 and the solution of the recursion is the following expression. So we can say that this is the solution will be stable only if A is from minus one to one and our stability condition returns the same result. Now we can plot several solutions for different values of parameter A to see that it is stable only in this case. As a second example, let's consider a system of two recurrence equations presented here. The fixed points of the system is the solution of following system of equations. We can solve it to see that we have a one fixed point at origin and r fixed points return the Same result. And this linear system is stable only if all eigenvalues of the coefficient matrix are in the range of minus one to one. And here our stability conditions will give some stability conditions here because we have parameters in the equation and we can plot the parameter region for which the system is stable. As a next example, let's consider a nonlinear recurrence equation which again can have more than one fixed point. So we can speak only about local stability in this case. So let's consider this equation. The fixed points are the solution of following equation. And we have two fixed points here, minus 5 and minus 3. And our fixed points returns the same result. And a nonlinear first order equation is stable near one of its fixed points if the linearized version of the equation is stable near that point. And here we can see that the point minus five is unstable and point minus three is stable. And we can use hover plot to visualize the stability. The last part of my talk will be about applications of stability analysis. As a first example, let's consider the damped pendulum equation given below. Here theta is the current angle of the pendulum. This example is interesting because it has infinite number periodic fixed points presented here. But due to periodicity of 2pi, we can use assumptions to specify the range of theta from 0 to PI to get only two most important fixed points. The first one corresponds to down position of the pendulum and is stable. And second one corresponds to up position of the pendulum and is unstable, as you can see here. Now we can use streamplot to get the phase portrait of the system Here. Red points are stable points and blue points are unstable points. And here is the solution to pendulum for some initial conditions. And the solution tends to its stable fixed point. As a next example, let's consider predator prey model. Let's consider an island with population of preys, for example rabbits, eggs of tea and predators, for example foxes. Phi of T. Preys have unlimited food resources and predators can eat only preys. This system can be described by so called Lotka Volterra equations presented here. So we can specify the values of parameters to construct our system. And this system has two fixed points, one at origin which is unstable and the other one at three, two which is stable. And again we can plot phase portrait of the system. And we see that both populations will oscillate near their equilibrium value or fixed point. And here is the plot of the solutions here. Blue line is the population of preys and yellow line is the population of predators. As a next example, let's consider so called Gauss Seidel method, which allows us to solve linear systems of equations of the form ax equal to B. Here, A is a matrix and X and B are vectors. Let's specify A and B and construct the Gauss Seidel recurrence equation. Now we can analyze the stability of Gauss Seidel recurrence equation using Gauss stability conditions. And we see that we have one fixed point, which is stable stability means that the method can be used to solve this linear system. But in fact we don't need to do that because the solution actually is this fixed point that we can easily verify with using linear solve. Since I don't have more time, I will stop here. But you can find much more interesting application examples in documentation pages of destability conditions and up stability conditions pages. Thank you for your attention.

All right, my name is Oliver and I work on ND solve PDE models and the finite element method. And today I'm going to be talking about what's new for PD models in version 14.1. Before I do that, I'll quickly like to jump to the core area page of the finite element method to give you a rough idea of what capabilities we have with the finite element method. So basically we have capabilities to do geometric modeling. So this is a helical bevel gear, a disc brake, things like that. All of this has been generated in the Wolfram language. So we have mesh generation. You see a mesh piston here, or we have this mesh crankshaft. We also have graded meshes and things like that. So that's also available. Now the next thing is we have various fields of physics for which we have, how to say, predefined PDE components, monographs and boundary conditions that we try to help you with for your actual PDE modeling. I do want to say, however, even though even if your field of physics is not presented here, that doesn't mean that we cannot solve it. It's just it doesn't have its own area that has been worked through, basically. So we offer things like heat transfer, fluid dynamics. So here's a blood flow in a cerebral aneurysm, mass transport. An interesting thing here is that we can take for example, images and convert them to meshes and then compute something from them. So this is a catalyst deactivation. We provide functionality for solid mechanics. What you see here is the deformation of a fiber reinforced material. We have models for hyper elastic materials and you can couple them with other fields of physics. So here's a hyper elastic material coupled with moisture and temperature. We have functionality in the area of acoustics, electromagnetics. I'm going to be talking about that in a second. Again, we can couple these fields of physics to do multiphysics analysis. So here we have a fluid flow and a heat transfer animation. We have various equation solvers, of course, integrated post processing. That's where we're really strong. So you have an analysis of a specific muffler. In this case, you can do the audio analysis. You can actually listen to the solution of your PDE model in this case. And for people that really want to get their hands dirty, you can actually also do finite element programming. Right. So let's get back to the presentation. Probably this second slide is the most important slide. If you want to do PD modeling, I suggest that you go to the PD Models overview page. And that page is in the help system. There is a little bit of an introduction here. And then you'll find the various fields of physics for which we have predefined areas. So if we look, for example at this heat transfer, we have heat transfer. That's the functions that are available. The monograph that accompany this, there is a list of PDE models that we've done. And at the end you'll find, for example, if you're looking for a specific case, like you want to do a 3D model, then you can look at this dual heating, laser welding and stuff like that. So that's how you find what functionality has been used in what application model. So this is a rough guidance on how to use the PD Models overview page. All right, so that being said, what's new in PD models? We've added new components for electromagnetics. We've updated some solid mechanics things, and we've updated the Schrodinger PD component. There is new functionality in the open cascade link. I'm not going to be presenting that today just to wetten your appetite. So in the open cascade link, which is our way to do fancy 3D CAD models, you can now do 2D drafting. So you can draft your, your sketch in 2D and then extrude it to 3D. So that's what's new there. But I'm not going to be presenting that today. Electromagnetics. So that's a field we've started looking at more closely. And for this version we've added two new monographs. There's an Electromagnetics overview and an electric Currents monograph. And we're going to look at some of these things just now. So in the Electromagnetics overview monograph, we discuss Maxwell's equation and the problem with Maxwell's Equations is there, I mean, a complicated set of several equations. And solving the full Maxwell's equation can be quite resource intensive. So you need a lot of hardware like CPU power and random access memory to solve these equations. So you always want to try to find simplified equations based on some assumptions. Now, finding which type of equation you want to use in the electromagnetic case is not always quite trivial. So for this we've set up a kind of a flow chart that you can use to identify what type of equation you should use for the specific problem you want to solve. So the first question you'd ask yourself is electromagnetic model in your case is that transient is a time dependent yes or no? If it's not time dependent, then we know that the electric and magnetic field time derivative is going to be zero. You can then decide do you only want to look at the electric field or the magnetic field? And that with a few other questions and leads you to what function you should use. So the electrostatic PD component is what we've had before and now we've added the electric current PD component. And there is some other stuff is coming in the future version. So you see a bit of a peek into the future what's going to come. So in this case, for a transient case, you look at the wavelength that you want to model. If you're in a low frequency quasi static case, you consider the skin depth and things like that. So all of that is explained in much detail in the electromagnetics overview. It helps you to find what equation you should use for your specific electromagnetics case. The new function that we've added is the electric current PD component. And here is that PDE in all its glory. So the function that generates this equation is the electric current PD component. And we, we can have a brief look at that. So this is the reference page again and as usual, in the details section you'll see all information that you need, what type of things you can specify cross sectional area, current source, electric conductivity, and what the default values are and things like that. So we're going to see an example in a second. And there's a new boundary condition, electric current density value that specifies the current density value on the boundary. We can do 1D 2D, 2D axis symmetric and 3D models, stationary and frequency models. We cannot yet do the time domain that's going to come in the next version, 14.2 or whatever that's called. And the reason is that in this component here we have a mixed time and spatial derivative which we currently cannot handle. We can Handle, but not straightforwardly in the finite element method.

Right.

So that's something for the future to come. So here's an example. It's basically the same example that Devendra already showed. I'm going to talk about this in some more detail. So what we want here is we have a wire that we want to apply a voltage difference to and want to see how the current flows in that wire. So this is the geometrical setup for this. This is the discretized wire. And now you start to specify the variable. So the electric potential in three spatial dimensions, XYZ are the independent variables. We've chosen tungsten as a material. You could either specify the material properties yourself, like the electrical conductivity, if you have that, or get a material from an entity. And the electric current PD component with the vars and parts that we just specified is going to give you the PDE operator. This is a very simple case just to illustrate basically what the workflow is. Then we specify boundary conditions. So we have an electrical potential condition at one end of the wire, and there we specify that the electrical potential is 0.2 volts. And we have a second electrical potential condition at the other end of the wire where we don't specify an electric potential and that that means it defaults to zero. So there's a zero electric potential at that end of the wire. You then call ndesolve value on this operator, set it to 0, specify the boundary conditions, dependent variables. And xyz is elemental of Omega, which returns an interpolating function. So that's same as usual. Now, to compute the current density vector, we extract the electrical conductivity and multiply it with the gradient of the electric potential. We just computed the negative of it and a slice density plot of the total square root of the electrical density can then be displayed. And what you see here is that there is more current flowing at the inner bends of the wire than not the outer bends. So that's maybe a bit of a surprising result, but that's what, what the equations give us. All right. We can also do, of course, other things with this. The electric currents. Here is a wire that you might find in an old light bulb. There you see the electric potential out specified and now it's coupled to a heat equation. And we see how the wire heats up in the when current is flowing through it. In this lower example, that's the result of modeling a capacitor. So we have some voltage applied at intervals and you'll see how the capacitor charges and discharges. So these are examples you can find in the documentation. Right. Change of gears, solid mechanics. So here we've added a new function called von misestress. And the goal is to compute the von Mises stress of a deformed body. And the reason is that you want something like this, is that you want to have a way to deal with, to not deal with a full stress tensor that's typically computed. We look at an example. So we have a geometry here. We specify variables and parameters. So U, V and W are the displacements in the x, Y and z direction. Material this time is titanium, something different now. And we specify the boundary conditions. So the PDE operator is the PDE that's generated. The solid boundary load value gives at the right hand side a force of two times to the 10 of seven in the negative Z direction. And on the left end, this object, the body, is held fixed and we can compute the displacement. Again, we just call ndsolve on this. And now what you typically do is you compute the strain from the displacement and the stress from the strains. This is going to give you a symmetrized array of the complete stress tensor. Now, this thing is very hard to work with. I mean, you can extract the different components. That's not a problem, but it's conceptually hard to work with. And this is where the von Mises stress comes in. So von Mises came up with a theory how to combine this, these components of the stress tensor into a single expression that's meaningful. And the function von Meser stress just does that. So it basically computes this object. It returns an interpolating function. And you can use a vector displacement plot to displace with the displacement and the flame's stress plotted on top of this. So what can you do with this? Why is this interesting? So the von Mises stress is a way to tell if a material is over the yielding limit. So if something is bent too much, it will sustain plastic deformation. And that's something you typically want to avoid. So we extract the von Mises limit from this material, the parameter, the tensile yield strength, and specify a criterion. So if this von Mises stress, what we just computed, is larger than the limit, then we'll highlight with 1 and 0 is not highlighted. So in this plot now you see where the object. Gets more force than it should because it can't sustain that limit. It's beyond this yield limit. All right, so that's basically what the von Mises stress function does. We've updated the Schrodinger PD component and the goal is to compute the time evolution of a wave packet under the presence of a magnetic vector potential with a non isotropic effective mass. And that demonstrates the Haranov Bohm effect. And we're going to have a look at this. So again we specify the variables. So psi, T, X, Y, T is a time dependent variable, XY are the spatial variables. And now what we can do is we can specify a mass that is anisotropic. So 0.07 and 0.05 are the anisotropy components of the electron mass. And we have at the same time a magnetic vector potential. The combination of the anisotropic mass with the vector potential is what's new. And this is the way to set up the equation. So here is a visualization of that. So we have the wave packet hitting a slit and we see that it's now slightly asymmetric because of the anisotropy of the mass. All right, there are a couple of new application examples I wanted to mention and I've given just a small choice of these new application examples. If you look in the documentation, you'll find a few more. So here's a new application example of thermal contact where we have a very thin gap between these two materials. This is heated and we'll see that there is a discontinuity at this gap. That's the resulting temperature plot. So this is if you want to work with discontinuities, that's probably something that's of interest for you. We have a new electrostatic application example where we couple solid mechanics with electrostatics. So first we compute the electrostatic field and then couple this into a solid mechanics component where we can then see the deformation of this cantilever that's induced by this electric potential difference. Another example I quickly wanted to mention is this cerebral aneurysm. So this models Navier Stokes equation with a non nutrient fluid model and it shows how the blood flows in this aneurysm. And we tend, we, we intend to work on this a bit in the future. We'll see how far we can get with that. Another example I quickly wanted to mention is there is a new extended monograph or extended application example. I'm sorry, on axis symmetric quantum dot. And this is an analysis of a single particle state confined in a semiconductor quantum dot. So these are some results. And you can also look at this in the documentation. This is just to give you a small overview of what's new. So what's the future of PDE modeling? So the next thing we are currently working on is magnetostatics. So we'll continue to extend the electromagnetics components with magnetostatics. So magnetostatics for permanent magnets and magnetic fields with currents that involve currents. And the second thing we're working is on plastic deformation. So the von Mises stress, what do you do if something is beyond the yield limit, then you want to be able to handle a plastic deformation. All right, so that concludes my presentation. And yeah, nd solve rocks. And thank you very much for your attention.

Thank you very much, Oliver, for that wonderful talk and thanks to all the speakers. Well, for this great set of talks on what has been a very nice release. When we do release of this type and ask people to give talks, they usually are sometimes hesitant. They don't want to really speak because we are not speakers and basically we are doers. We do development. But this particular release has been, I think, a very easy one to talk about. And I'll go around the speakers and give them a chance to talk about the experience, the release. But from my point of view, the one feature that I did work on is the D solve with one argument which came from WolframAlpha. Just so you know, the interaction between WolframAlpha and Mathematica. WolframAlpha does use quite a bit of Mathematica for dsolve and they noticed that people give simpler syntax. So we did it. There is a problem that with wolframal for Chat GPT, they can afford to say stuff which may not be exactly precise or even correct. In some sense we have to be a bit more careful. So that's the balance we drive. So this release was about making D solve shorter the input. So but in a future release we might do something like make some convergence a little longer. So people have requested that the syntax for some convergence which does convergence testing should look like sum. So I'm just saying that, you know, we have a battle over here. We have new functions for every release, and then these classic old functions which also need maintenance and polishing and other improvements. I'm saying all this because I noticed there's a question about a bugger integrate, an example which didn't quite work right. And Andrew very correctly said that, you know, we should report to tech support for further information. But on my side, I think these are important just to give some insight. The main method we have for that kind of very general symbolic multiple integral is iterate integration, but that's all algebraic in this case. By algebraic I mean there are square roots. That's a really hard problem for branch cuts. So we will look into it. Be assured. I think it's important that we do well on the old functions just as we put in a lot of effort into making new functions to keep everyone engaged and interested. So that's from my side. It's been really good release, but let's just go around and give people a chance to talk about their experience. I know Aram spends some time on looking at literature dynamical systems. Maybe you can give some references which you found useful for your own work on this feature.

I just want to mention here, I didn't mention about it during the talk that currently these features, the stability conditions and defixed points also as stability points are working for autonomous linear or nonlinear systems. And there is a well known Floke theory or Floki theorems which make it possible also to do stable analysis for non autonomous systems with periodic periodic coefficients. And we are working on red directions so maybe near future we will load also some cases for non autonomous systems. And since I don't see any unanswered questions about my topic, I just want to thank the audience one more time and also the organizers for such a wonderful opportunity for us to present our latest results and latest new features.

Yes, thank you Aram. And what we notice is that many of our own users have been building these galleries of dynamical systems over the years and what you've done in the documentation for these new functions for destability and condition etc. Is to actually put those examples into a documentation to kind of collect them together with more modern notation for animations, et cetera. So I think this is a feature that completes out the area of differential equations. Every textbook on differential equations will have a chapter on nonlinear differential equations. If you look at Boys and Diprium, I think it's chapter nine probably yes. So I'm really happy to see this. Oh good. So I think I got it right. So I've always felt that chapter nine was the one I read in every differential equations book. Now it's done. So that's great Aram, thank you very much for that chat. Really interesting and informative talk. Maybe I should go on to Itayan, who spent a lot of time who spent a lot of time over the years actually. First on the tensor functionality about it, there's some kind of question, I mean the issues you have so many different ways of looking at these things. So Itay, what were the most challenging parts of your development for the work for this release? Was it typesetting? Was it some other design issues? What what you think took up most time for you?

Well, I, you know, I was obviously the core typesetting guy so that, that's been, I spent a lot of time with that.

But beautiful, right?

The, you know, there were, you know, I think, I think the trickiest bit was making the old and new stuff interoperate because there were sort of different.

You know.

Each one has its own advantages and disadvantages and therefore its own quirks and sort of making them interoperate nicely was somewhat tricky. I think we, we did a pretty good job of that. Maybe not perfect, but certainly very good. I do want to answer actually one question that I see has just popped up here which isn't directly related to my talk, but there's a question about the number of cores used. So we don't limit the, the amount of, of cores based on your license, but we on, on Macs with Apple Silicon we limit by default to use the. Only the, you know, the, the. I forget what they're called, but the power cores rather than the efficiency cores because we found we generally get that better performance that way that's customizable. If you want to change the number of threads to use all your cores, you can and there may be specific computations for which that's more efficient but we don't limit the number of cores we use based on the license. So that is that question. And yeah, that's great.

I think so. Ita of course is also the expert on Mac issues. So often he just gets dragged into fixing something on the Mac which he really knows about. So I think that we have had really good response from Itai and Aram and maybe Oliver, you can talk. I mean I'm pretty amazed that we can do this kind of modeling on the biological front. So how far do you think maybe you can just talk about what particular feature in the release has been most kind of, you know, challenging for the team. Right, Go ahead.

Yeah. So I mean for the electromagnetics it is challenging because we don't have all functionality available yet. But at the same time we need to design the current functions so that they fit nicely together with all future functionality. So it takes some time to put some thought into how to make them work together nicely even though we don't currently have them yet. It requires that you have a good understanding of what's going to come in the future and try not to move yourself into a one way street, so to speak. That's challenging. I mean other areas, for example solid mechanics, I mean also electromagnetics, the theory behind these areas is not entirely trivial. And that's, I mean that's the reason why we provide these functions so that it's easier for customers to set up the equations and, and make it less error prone. I mean, you could have done many of these things before without using these PDE components. But I've had many requests or many interactions with customers either on Stack Exchange or through the customer support where in the end it turned out that some equation setup was just not quite right. And this is the way to avoid that these functions are tested, we know that they work and it should help you make more or get easier to a result that is. And yeah, so going forward I think we'd like to fill out more different fields of physics with more monographs so people that lie on you in the area can get a head start with that. Reading these monographs. Yeah, that's basically the challenging thing. I mean writing these is also quite a lot of work and we try to accompany every new function with an entire book basically to explain what we think the workflow should be and how it works with other functions and things like that. So that's quite a lot of work to do, but I think it's worth it.

Yes, thank you Oliver for the insight. I think it's been a great session. We've had formal talks, we've had some informal chat and it's time to hand back to the team to.

If I can have just.

Sure, of course.

20 seconds. Today's Mac build failed, but today's Linux build did not fail. You see, this is from August 14th and as I promised we have this new function called array expand and it does prove this identity and it cancels out the things which are cancellable but leaves the things that are not cancellable alone. So like just since I did want to. Since I did promise that, I wanted to circle back and show that indeed we are working on this and we'll have more to show in that next release.

Yes, there's always something to look forward to, isn't there?

Thanks Jimmy, go ahead.

Thanks Devendra. Thanks to everybody and our behind the scenes staff as well. There's going to be a short survey that shows up on your in your browser. If you would click to your survey and provide us with some feedback. You also have the opportunity to request a certificate of attendance from this event today. We do hope that you'll be joining us at upcoming webinars in the series. Next week we'll be covering updates for the Wolfram compiler system modeler and external language integration with another impressive roster of Wolfram developers. So we look forward to seeing you next week, everyone.

Thanks.