In traditional mathematical science, the very favorite kinds of systems used as models of things are so-called partial differential equations. And they're different from everything I've been talking about here, because they don't have discrete elements; they're continuous.
World Scientific Series On Nonlinear Science Series A
Well, with Mathematica it's easy to write down possible symbolic equations, and start searching through them. And when I did that, I quickly found these. They're just simple nonlinear PDEs. But even with very simple initial conditions, they end up doing all sorts of complicated things. Well, actually, it's a little hard to tell precisely what they do. Because with a continuous system like this there's always a problem.
Because you end up having to discretize it, and without already more or less knowing the answer, it's hard to tell whether what you're seeing is something real. But in a discrete system like rule 30, the bits are the bits, and one can tell one's seeing a real phenomenon. And actually, rule 30 is so simple to set up, that young kids can certainly do it—and there's probably no reason the Babylonians couldn't have done it. And I've sometimes wondered whether perhaps they did—and whether someday some ancient mosaic of rule 30 might be unearthed. But if you look at the motifs of ornamental art through the ages, you don't see any rule 30s.
It's interesting to track down the details of these; I discuss them in the notes at the back of my book. And for example, so far as I can tell, the earliest time a good nested structure shows up is It's in mosaics made by the Cosmati. But actually, it shows up only for a few years. Then disappears for hundreds of years. I was really excited when I found a picture of this from around There've been a lot of near misses over the centuries. But I don't think anything quite like rule 30 was actually ever created. Because if rule 30 had been known in antiquity, I suspect a lot of ideas about science and nature would have developed rather differently.
Because as it is, it's always seemed like a big mystery how nature could manage—apparently so effortlessly—to produce so much that seems to us so complex. It's like nature has some special secret that allows it to make things that are much more complex than we as humans normally build. And often it's seemed like that must be evidence that there's something some force beyond human intelligence involved. But once one's seen rule 30, it suggests a very different explanation. It suggests that all it takes is for things in nature to follow the rules of typical simple programs.
And then it's almost inevitable that—like in the case of rule 30—their behavior can be highly complex. The way we as humans are used to doing engineering and to building things, we tend to operate under the constraint that we have to foresee what the things we're building are going to do. And that means that we've ended up being forced to use only a very special set of programs—from a very special corner of the computational universe—that happen always to have simple foreseeable behavior. But the point is that nature is presumably under no such constraint.
So that means that there's nothing wrong with it using something like rule 30—and that way inevitably producing all sorts of complexity. Well, there's a huge amount one can do by abstractly exploring the computational universe. A huge intellectual structure to build—a bit like a pure mathematics. And an important source of ideas and raw material for technology—and for things like architecture.
But for natural science the crucial thing is that it gives us new kinds of models—and new fundamental mechanisms for behavior. And it gives us the intuition that in the computational universe there really can be extremely simple rules that are responsible for complex forms and phenomena we see. Well, crystals grow by starting from a seed, then successively adding pieces of solid. And one can try to capture that with a simple two-dimensional cellular automaton. Imagine a grid, where every cell either has solid in it or not.
Then start from a seed and have a rule that says solid will be added at any cell that's adjacent to one that's already solid. Here's what one gets. Play Animation It's an ordinary-looking faceted crystal, here on a square grid. One can do the same thing on a hexagonal grid. Play Animation But for snowflakes there's an important effect missing here. When a piece of ice solidifies, there's always some latent heat released. And that inhibits more ice nearby. Well, what's the simplest way to capture that effect?
Just change the cellular automaton to say that ice gets added only if there's exactly one neighboring cell of ice. OK, so what happens then? Well here's the answer. Play Animation These are all the stages. And these look an awful lot like real snowflakes. It really seems like we've captured the basic mechanism that makes snowflakes have the shapes they do. And we get various predictions: like that big snowflakes will have little holes in them. Which indeed they do. OK, but even though our pictures have forms that look a lot like real snowflakes, there are details that are different.
But the thing one has to understand is that that's what's going to happen with any model. Because the whole point of a model is to capture certain essential features of a system—and then to idealize away everything else. And depending on what one's interested in, one may pick out different features to capture. And so the cellular automaton model is good, for example, if one's interested in the basic question of why snowflakes have complicated shapes—or what the distribution of shapes in some snowflake population will be. But it's not so useful if one's trying to figure out specifically how fast each arm will grow at a certain temperature.
I might say that among natural scientists there's a general confusion about modeling that often seems to surface when people first hear about things like cellular automata. They'll say: OK, it's all very nice that cellular automata can reproduce what snowflakes do, but of course real snowflakes aren't actually made from cellular automaton cells. Well, the whole point of a model is that it's supposed to be an abstract way of reproducing what a system does; it's not supposed to be the system itself.
I mean, when we have differential equations that describe how the Earth moves around the Sun, we don't imagine that inside the Earth there are all sorts of little Mathematica s solving differential equations. Instead, it's just that the differential equations represent—abstractly—the way the Earth moves. And it's exactly the same thing with models based on cellular automata: the cells and rules abstractly represent certain features of a system. And again, what abstract representation—what type of model—is best, depends on what one's interested in.
For snowflakes there are traditional differential equations that could be used. But they're complicated and hard to solve. And if what one's actually interested in is the basic question of why snowflakes have complicated shapes, the cellular automaton model is a much better way to get at that and to work out predictions about it. OK, let's take another example. Let's talk about a wonderful generator of complex forms: fluid turbulence. Whenever there's an obstacle in a fast-moving fluid, the flow around it looks complicated and quite random.
But where does that randomness come from? The most traditional is that randomness comes from external perturbations. Like, say, a boat that moves randomly because it's being randomly tossed around by the randomness of an ocean surface. Another source of randomness is chaos theory. Where randomness comes from details of how a system is started. Like with a coin toss. Where which way it'll land depends sensitively on its initial speed. And if it was started by hand, there'll always be a little randomness in that—so the outcome will seem random.
Well, there are more elaborate versions of this, where one's effectively taking numbers that represent initial conditions, and successively excavating higher- and higher-order digits in them. And from the perspective of ordinary continuous mathematics, it's a bit tricky to account for where the randomness comes from here. But in terms of programs it becomes very clear that any randomness is just randomness one put in, in the detailed pattern of digits in the initial conditions.
So again one ends up saying that "randomness comes from outside the system one's looking at. OK, well. So is there any other possibility? Well, it turns out there is. Just look at rule Here one doesn't have any randomness initially. One just has a single black cell. And one doesn't have any subsequent input from the outside. But what happens is that the evolution of the system just intrinsically generates apparent randomness.
Well, that's where I think most of the randomness in fluid turbulence—and a lot of other places—comes from. One can get evidence by making detailed models—that can be pretty important for practical applications. But there's also a general prediction. See, if the randomness comes from the environment or from details of initial conditions, it'll inevitably be different in different runs of an experiment. But if it's like rule 30, then it'll always be the same every time one runs the experiment.
So this says that in a carefully enough controlled experiment, the turbulence should be exactly repeatable. Apparently random. But repeatably so. Well, OK, what about biology? That's probably our richest everyday example of complex forms and complex behavior. But where does it all come from? Ever since Darwin, people have figured it's somehow got to do with adaptation and natural selection.
But in reality it's never been clear why natural selection should actually lead to much complexity at all. And that's probably why—at least outside mainstream science—people often think there must be something else going on. But the question is: what is it? Well, I think that actually it's just the abstract fact—that we discovered with rule 30 and so on—that among simple programs it's actually very easy to get complexity. Of course, the complete genetic program for a typical organism is pretty long and complicated—for us humans about the same length as the source code for Mathematica.
But it's increasingly clear that lots of the most obvious aspects of forms and patterns in biology are actually governed by rather small programs. And looking at some of the kinds of regularities that one sees in biological systems, that doesn't seem too surprising. But when one sees more complicated stuff, traditional intuition tends to suggest that somehow it must have been difficult to get. And with the natural selection picture, there's sort of the idea that it must be the result of a long and difficult process of optimization—or of trying to fit into some complicated ecological niche.
Well, I actually think that that's not where many of the most obvious examples of complexity in biology come from. Natural selection seems to be quite good at operating on small numbers of smooth parameters—lengthening one bone and shortening another, and so on. But when there's more complexity involved, it's very hard for natural selection to operate well. And instead, what I think one ends up seeing is much more just the outcome of typical randomly-chosen simple genetic programs.
So that what we see in biology is in a sense a direct reflection of what's out there in the computational universe. Let me give you an example. Here are some mollusc shells with pretty complicated pigmentation patterns on them. Well, in the past one might have assumed these must be difficult to get—the result of some sophisticated biological optimization process.
But if you look at the patterns, they look incredibly similar to patterns we get from cellular automata like rule Well, in the actual shell, the pattern is laid down by a line of pigment-producing cells on the growing edge of the shell. And actually it seems that what happens can be captured rather well by a cellular automaton rule. But why one rule and not another? But there are definite classes. And here's the remarkable thing: those classes are the same classes of behavior that one sees if one looks at all possible simplest relevant cellular automata. Well, that's rather remarkable.
It's very much as if the molluscs of the Earth are little computers—sampling the space of possible simple programs, and then displaying the results on their shells. You know, with all the emphasis on natural selection, one's gotten used to the idea that there can't be much of a fundamental theory in biology—and that practically everything we see must just reflect detailed accidents in the history of biological evolution.
But what the mollusc shell example suggests is that that may not be so. And that somehow one can think of organisms as uniformly sampling a space of possible programs. So that just knowing abstractly about the space of programs will tell one about biology. One might think they're too diverse to explain in any uniform way. But actually it turns out that there's a simple type of program that seems to capture almost all of them. It just involves successive repeated branchings. And what's remarkable is that the limiting shapes one gets look just like actual leaves, sometimes smooth, sometimes jagged, and so on.
And you can see that like with so many other simple programs, you can get all sorts of different forms just by changing the program a bit. To be a little more sophisticated one can actually summarize features of all possible leaves in a parameter space set—that turns out to be a rather wonderful simpler, linear analog of the Mandelbrot set. And from the properties of this set one can deduce all sorts of features of leaves and their likely evolution. Well, I've spent a long time figuring out how all sorts of biological forms get made—how they get grown. And there's a lot to say about biology—not only at the level of macroscopic form, but also at molecular levels.
You know, if one looks at the history of biology, there's an interesting analogy. About fifty years ago, there was all this data on genetics and heredity, and it seemed really complicated. But then along came the idea of digital information in DNA, and suddenly one could see a mechanism. Well, there are now a bunch of people who think that my science might lead us to the same kind of thing for big issues in biology today, like aging and cancer.
And that somehow by thinking in terms of simple programs, one may be able to see the right primitives, and tell what's going on. Which of course would be very exciting. Well, OK, let me turn for a few minutes back to physics. And in particular fundamental physics. Now this is supposed to be an architecture talk, so I'm not going to go too deep into this.
For the physicists though: read Chapter 9 of the book. Well, so, what does the computational universe tell us about how our actual physical universe might work? Traditional mathematical approaches have definitely done pretty well in physics. But still they haven't been able to give us a truly fundamental theory of physics. And I think the reason is that one needs more primitives than just the ones from traditional mathematics.
And now that we've seen some of what else can happen in the computational universe, one can't help wondering whether perhaps all the things we see in our universe couldn't just be the result of some particular simple program.
3 body problem chaos
That'd be pretty exciting. To have a little program that's a precise ultimate model of our universe. So that if one just runs that program long enough it'll reproduce every single thing that happens in our universe. But, OK, what might such a program be like? Well, one thing that's kind of inevitable is that very few familiar features of our universe will immediately be visible in the program. There just isn't room. I mean, if the program is small, there's just no way to fit in separate identifiable pieces that represent electrons, or gravity, or even space or time.
And in fact I think that if the program's going to be really small, it sort of has to have the very least possible structure already built in. And for example I think a cellular automaton already has far too much structure built in. For example, it's already got a notion of space. It's got a whole rigid array of cells laid out in space. And I don't think one needs that. I mean, in ordinary physics, space is a kind of background—on top of which matter and everything exists.
Books by Leon O. Chua (Author of Linear and Nonlinear Circuits)
But I think that in an ultimate model, one in effect only needs space—one doesn't need any other basic concepts. Well, OK, so given that, what might space be? We normally think of space as just being something that is —not something that has any kind of underlying structure. But I think it's a little like what happens with fluids. Our everyday experience is that something like water is a continuous fluid. But we actually know that underneath, it's made up of lots of little discrete molecules. And I think it's something similar with space. That at a small enough scale, space is just a huge collection of discrete points.
Actually, really, a giant network. Where all that's specified is how each node—each point—is connected to others. I'm not going to go far into this here. There's a lot more in the book. It's a subtle business. With some fascinating modern math. But let me just say that when there are enough points, there's effectively an emergent geometry.
And one can get flat or curved space, in a definite number of dimensions, like three. Well, what about time? In a cellular automaton there's a global clock. But here it's much more subtle. The network might evolve by updating pieces with rules like these. Play Animation But it turns to be really hard to tell what order the updates should be done in. And one might just think that somehow every order happens, so that there's a whole tree of possible histories for the universe.
But it turns out that there's another possibility. Certain rules have a rather unexpected property that I call causal invariance. Which implies in effect that whatever order the updates get done in, one always gets the same causal relations between actual events in the universe. And here's the exciting thing: not only does this make there be a definite thread of time in the universe; it also immediately implies special relativity.
And that's not all. It looks as if in a certain class of these network systems general relativity and Einstein's equations for gravity come out. Which is really quite amazing. It's subtle and sophisticated stuff. But there are also a lot of hints that from these networks, with their little replacement rules, one can get many fundamental features of quantum mechanics and quantum field theory. But so how is one going to find the program for the universe? Well, if it was a complicated one we would have no choice but to do what we've normally done in physics—or in science in general—which is to sort of reverse-engineer the program from data we see.
But if the program is simple enough, there's another possibility: we can just search for it. Just look out in the computational universe, trying rule after rule and seeing if any of them is our universe. At first, that seems completely crazy. But if the rule really is simple, it's not crazy at all. Of course it's not easy. It takes a lot of technology.
- 3 body problem chaos;
- Educational Futures: Dominant and Contesting Visions (Futures in Education);
- Domestic violence: a reference handbook.
New methods of automation. And you can watch for those things as they spin off into future versions of Mathematica. It's going to be fascinating—and perhaps humbling—to see just where our universe is. The hundredth rule? Or the millionth? Or the quintillionth? But I'm increasingly optimistic that this is all really going to work. And that eventually out there in the computational universe we'll find our universe.
With all of our physics. And that will certainly be an exciting moment for science. I want to come back now to the original discovery that really launched everything I've been talking about: the discovery that out in the computational universe even simple programs—like rule 30—can produce immensely complex behavior.
So why does that happen? What's the fundamental reason? To answer that one needs to set up a somewhat new conceptual framework. And the basis of that is to think about all processes as computations. The initial conditions for a system are the input. And the behavior that's generated is the output. Well, sometimes the computations are ones that we—kind of—immediately know the point of. Like here's a cellular automaton that computes the square of any number. And here's a cellular automaton that generates the primes. But actually any cellular automaton can be thought of as doing a computation.
It just isn't necessarily a computation that we know the point of beforehand. OK, so we have all sorts of systems and they do all sorts of computations. But how do all these computations compare? Well, we might have thought that every different system would always do a completely different kind of computation. But the remarkable idea that's now about 70 years old is that no, that's not necessary.
Instead, it's possible to make a universal machine that can do any computation if it's just fed the right input. And of course that's been a pretty important idea. Because it's the idea that makes software possible, and really it's the idea that launched the whole computer revolution. Though in the past, it never too relevant to things like natural science. Or all the systems we see in nature? How sophisticated are the computations that they're doing? Well, I spent a long time thinking about this and accumulating all sorts of evidence. And what I ended up concluding is something that at first seems pretty surprising.
I call it the Principle of Computational Equivalence. It's a very general principle, and in its roughest form what it says is this: that essentially any time the behavior of a system looks to us complex, it will end up corresponding to a computation of exactly equivalent sophistication. If we see behavior that's repetitive or nested then it's pretty obvious that it corresponds to a simple computation. But what the Principle of Computational Equivalence says is that when we don't see those kinds of regularities, we're almost always dealing with a process that's in a sense maximally computationally sophisticated.
Now at first that's pretty surprising. Because we might have thought that the sophistication of the computations that get done would depend on the sophistication of the rules that got put in. But the Principle of Computational Equivalence says it doesn't. And that immediately gives us a prediction. It says that even though their rules are extremely simple, systems like rule 30 should be computation universal. Well, normally we'd imagine that to achieve something as sophisticated as computation universality we'd somehow need sophisticated underlying rules.
And certainly the computers we use that are universal have CPU chips with millions of gates, and so on. But the Principle of Computational Equivalence says you don't need all of that. It says that even cellular automata with very simple rules should be universal. Well, here's one them. This is rule The hundred-and-tenth of the elementary cellular automata I showed earlier. It's got that really simple rule at the bottom. But as you can see, it does some fairly complicated things.
It's got all these structures running around that seem like they might be doing logic or something. But can one really assemble them to get something one can see is universal? Well it turns out that one can. And that means that rule is indeed universal! Well, that's just what the Principle of Computational Equivalence said should be true.
But it's still a remarkable thing. Because it means that this little rule can in effect produce behavior that's as complex as any system. One doesn't need anything like a whole computer CPU to do universal computation. One just needs this little rule. And that has some very important consequences. Particularly when it comes to thinking about nature. Because we wouldn't expect to find whole computer CPUs just lying around in nature. But we definitely can expect to find things with rules like rule And that means for example that lots of everyday systems in nature are likely to be universal.
Which is pretty important for both science and technology. By the way, for computer science folk: for 40 years this had been the simplest known universal Turing machine. And in fact I suspect that this little thing is the very simplest Turing machine that's universal. Well, there's a lot to say about what the Principle of Computational Equivalence is, and what it means. One thing it does it to make Church's thesis definite by saying that there really is a hard upper limit on the computations that can be done in our universe. But the place where the principle really starts to get teeth is when it says that not only is there an upper limit—but that limit is actually reached most of the time.
With incredibly simple rules one'll often get just simple behavior that's, say, repetitive or nested. But the point is that if one makes the rules even a tiny bit more complicated, then the Principle of Computational Equivalence says that one immediately crosses a threshold—and ends up with a system that's maximally computationally sophisticated. And it also says that this should happen for lots of initial conditions—not just special ones. OK, so what does all this mean?
Well, first of all it gives us a way to answer the original question of how something like rule 30 manages to show behavior that seems so complex. The point is that there's always a competition between an observer and a system they're observing. And if the observer is somehow computationally more sophisticated than the system, then they can in a sense decode what the system is doing—so it'll look simple to them. But what the Principle of Computational Equivalence says is that in most cases the observer will be exactly computationally equivalent to the system they're observing.
And that's then why the behavior of the system will inevitably seem to them complex. Well, a related consequence of the Principle of Computational Equivalence is a very important phenomenon that I call computational irreducibility. Let's say you know the rules and the initial condition for a system. Well, then you can certainly work out what the system will do by explicitly running it. But the question is whether you can somehow shortcut that process.
Can you for example just work out a formula for what will happen in the system, without ever explicitly having to trace each step? If you can, then what it means is that you can figure out what the system will do with a lot less computational effort than it takes the system itself. And that kind of computational reducibility is at the core of most traditional theoretical science. If you want to work out where an idealized Earth will be a million years from now, you don't have to trace all its million orbits; you just have to plug a number into a formula and get out a result.
But the problem is: what happens when the behavior is more complex? If a system is repetitive—or even nested—it's easy to shortcut things. But what about a case like this? Or lots of the other things we saw in our experiment. There's certainly no obvious way to shortcut this. And in fact I think it's computationally irreducible: there's essentially no way to work out what the system will do by any procedure that takes less computational effort than just running the system and seeing what happens.
In traditional theoretical science, there's sort of been an idealization made that the observer is infinitely computationally powerful relative to the system they're observing. But the point is that when there's complex behavior, the Principle of Computational Equivalence says that instead the system is just as computationally sophisticated as the observer. And that's what leads to computational irreducibility. And that's in a sense why traditional theoretical science hasn't been able to make more progress when one sees complexity.
There are always pockets of reducibility where one can make progress, but there's always a core of computational irreducibility. Well, I think computational irreducibility is a pretty important phenomenon. With a lot of consequences—both practical and conceptual. At a practical level, it shows us that computer simulation isn't just convenient, but fundamentally necessary. Which puts more pressure on finding the computationally simplest underlying models.
At a more conceptual level, it gives us a new way to understand the validity—and limitations—of the Second Law of Thermodynamics. And at a philosophical level, it finally gives us a concrete mechanism for the emergence of apparent free will from deterministic underlying laws. Computational irreducibility is also behind the phenomenon of undecidability—originally discovered in the s. Look at this cellular automaton. With the first initial condition, we can quickly tell that it dies out. With this one, it takes steps. But what's going to happen in the end in these cases? If there's computational irreducibility it may take us an infinite time to find out—so it's formally undecidable.
Well, undecidability has been known about in mathematics and in computer science for quite a long time. But with the Principle of Computational Equivalence one realizes now that it's also relevant to natural science. If one asks questions about infinite time or infinite size limits, the answers can be undecidable. Like whether a body will ever escape in a gravitational three-body problem. Or whether some idealized biological cell line will grow forever or will eventually die out.
Or whether there's a way to arrange some complicated molecule into a crystal below a certain temperature. Or, for that matter, whether particular idealized urban-planning rules will lead to infinite urban sprawl. Well, there's another big place where I think computational irreducibility is very important, and that's in the foundations of mathematics.
It may sound kind of obvious, but it's really a deep observation about mathematics that it's often hard to do. Yet it's based on pretty simple axioms. In fact, right here are the ones for essentially all of current mathematics. But even though these axioms are simple, proofs of things like Fermat's Last Theorem are really long. And it turns out that one can think of that as just another case of the phenomenon of computational irreducibility. There's a lot to say about this. And for people who are interested, it's discussed in Chapter But let me just say a few things here. Here's a visual representation of a simple proof in mathematics.
You start at the top. Then at each step use one of the axioms. And eventually prove the theorem that the expression at the bottom is equivalent to the one at the top. Well, OK, so as a minimal idealization of math, imagine that the axioms just define transformations between strings.
So with the axioms at the bottom here, here are proofs of a few theorems. But how long do the proofs need to be? Well, here's a picture for three axiom systems showing the network of all possible transformations. And the way this works, every possible path through each network corresponds to the proof of some theorem. Well, the point is that the shortest path from one particular string to another may be really long. And that means that the theorem that the strings are equivalent has only a really long proof.
Well, when people were thinking about formalizing mathematics a century ago, they kind of assumed that in any given axiom system it'd always eventually be possible to give a proof of whether a particular statement was true or false. But as such it doesn't seem like a statement in arithmetic. But somehow in all these years it's never seemed too relevant to most of the things working mathematicians deal with.
But here's the thing: the Principle of Computational Equivalence should be general enough to apply to systems in mathematics. And it then says that computational irreducibility—and undecidability—should actually not be rare at all. So where are all these undecidable statements in mathematics? Well, it's been known for a while that there are integer equations—so-called Diophantine equations—about which there are undecidable statements. Well, this is obviously pretty complicated, and not something that would show up everyday.
But what about simpler Diophantine equations? Here are a bunch. Well, linear Diophantine equations were cracked in antiquity. Quadratic ones around And so far another kind seems to be cracked roughly every fifty or a hundred years. But I'm guessing that that's not going to go on.
And that actually many of the currently unsolved problems in number theory will turn out to be undecidable. OK, but why has so much math successfully been done without running into undecidability? I think it's kind of like theoretical physics: it's tended to stick to places where there's computational reducibility, and where its methods can make progress.
- Nonlinear Dynamics Perspective Of Wolfram S New Kind Of Science Volume Vi Chua Leon O.
- Navigation menu!
- New Kind of Science | Applied Mechanics Reviews | ASME Digital Collection.
- Constitutional Political Economy in a Public Choice Perspective.
- Small Lives.
- VTLS Chameleon iPortal Browse Results;
- Navigation menu.
But at least in recent times mathematics has prided itself on somehow being very general. So then why haven't rule 30 and rule and all the phenomena I've found in simple programs shown up? Well, I think part of the reason is that mathematics isn't really quite as general as advertised. To see what it could be, one can imagine just enumerating possible axiom systems. And for example this shows what theorems are true for a sequence of different axiom systems. It's like an ultimately desiccated form of mathematics: the axioms go down the left, the theorems go across the top—and every time there's a theorem that's true for a particular axiom system there's a black dot.
So is there something special about the actual axiom systems that get used in mathematics? Perhaps something that makes undecidability less rampant? Well, if one looks at axiom systems from textbooks, they're usually pretty complicated. Here's logic, for instance. Well, it's been known for a hundred years that one doesn't have to have all those operators in there. The single Nand operator—or Sheffer stroke—is enough. E King. Solution of Certain Problems in Quantum Mechanics.
Computational Thermo-Fluid Dynamics. Petr A. Electromagnetism and Interconnections. Stephane Charruau. Non-diffracting Waves. Hugo E. John D. Advanced Computational Materials Modeling. Miguel Vaz Junior. Numerical Analysis Using R. Graham W. Diversities in Quantum Computation and Quantum Information. Mikio Nakahara. Mathematical Methods and Models in Composites.
Finite Element Analysis with Error Estimators. Quantum Information and Computation for Chemistry. Sabre Kais. Sujaul Chowdhury. Strong Light-Matter Coupling. Advances in Chemical Physics. Stuart A. Computational Materials Engineering. Koenraad George Frans Janssens.
Performance-Based Gear Metrology. William D. Computational Photonics. Salah Obayya. Marc E. Atomistic Computer Simulations. David R. Advances in Imaging and Electron Physics. Peter W. Balgaisha Mukanova. Alexander Ya. Lance Dixon. Fractals in Physics. Structural Stability and Vibration. Sine Leergaard Wiggers. Computational Problems for Physics. Rubin H. Rheology of Emulsions. Aleksandar M. Quantum Metrology with Photoelectrons. Paul Hockett. Michael Leschziner.
Multiscale Methods. Jacob Fish. A Guided Tour of Light Beams. David S Simon. Feynman And Computation. Anthony Hey. Predictive Control for Linear and Hybrid Systems. Francesco Borrelli. Exterior Billiards. Alexander Plakhov. Finite Element Simulation of Heat Transfer.
Jean-Michel Bergheau. Operator Algebras and Applications. Sergey Neshveyev.
Chaos, Complexity and Transport. Xavier Leoncini. Yasumasa Nishiura. Quantum Theory from a Nonlinear Perspective. Dieter Schuch. Yanzheng Zhu. Dynamics of Information Systems: Mathematical Foundations. Alexey Sorokin. Jie Zhang. Differential and Difference Equations with Applications. Sandra Pinelas. Viscous Flows. Ahmer Mehmood. Complex Systems and Networks. Xinghuo Yu. Michel Deville. Benjamin Lingnau. Vlastislav Cervany. Stochastic Processes and Long Range Dependence.
Gennady Samorodnitsky. Amina Eladdadi. Computational Quantum Chemistry. Joseph J W McDouall. Progress in Optics. Taco Visser. Improving Homeland Security Decisions.