If the universe is lazy evaluating things discretely down to scales well below that of observation, there's probably no damned way to tell the difference.
If it's atoms or photons doing the observing, though, they're affected by the gravitational pull of every mass in their light cone. So an atom can distinguish between universes in which another atom 1000ly away moved by 0e or 1e (where e is the distance between two lattice points).
But, it wouldn't have to know until 1000 years later. There does seem to be some computation-resource saving mechanic at play, but I don't think it has to do with discretization.
This is similar to aliasing in signal processing. A high frequency signal behaving like low frequency. And there are solutions to this problem, but it's hard to reason which one is the "right" solution.
Certain parts of QFT work fine in lattice based calculations (lattice-QCD, for instance, where it’s simulated on a certain lattice scale, and then extrapolated to the continuous limit), and some seemingly don’t work at all.
It feels like you want to do sth like: first discretize (choose a lattice), then simulate (do calculations on this lattice).
I want to do the opposite: first simulate (do calculations on a continuous domain), then discretize (restrict my results to a lattice).
> For your case you showed, it would be like if x^2 simply didn’t exist on a lattice, and couldn’t be calculated by a computer no matter how much memory you threw at the problem.
So the functions we're talking about do exist on continuous domains - but they don't have a corresponding definition on a lattice?
Couldn't we embed a lattice in the continuous domain, then restrict the function along the embedding, thus getting a definition on a lattice?
Unless it's not possible to embed the lattice in a continuous domain - then my reasoning breaks.
(note: I know nothing about physics, I'm a programmer with math education, talk to me like I'm an idiot)
But the point to remember is that these aren’t normal algebraic equations, they’re based on the quantum operators, right? And so we can always do symbolic math on them, but to get numeric results, they have to be instantiated at some point. The operators exist at every point in space, and some of the operators can be approximated on a lattice discretization, but some of them cease to be well defined as soon as there is any distance between the operators (so they require true real numbers, not floating point numbers - ergo, infinite memory).
One point that i think is missing is that there’s a bit of a difference between numerical solutions to QFT equations (like the calculation of g-2 referenced in the paper) and lattice calculations in that in general those numerical calculations are giving averaged quantities. We couldn’t, for instance, take that average quantity and use it instead of the dynamically fluctuating quantity in a lattice simulation. We could run a lattice simulation and estimate the value of g-2 from the lattice to see how well our discretization -> continuum extrapolation worked. But we couldn’t go backwards from the numerical solution to the lattice, so to speak.
But how do you compute the continuous answer in the first place?
Then we express the value of any particle field at every point as a (potentially very complex) symbolic expression that only uses the state function from my previous paragraph.
All of these expressions need only finite memory to store. They describe functions with domain R^n to some co-domain of operators or whatever.
Then I can calculate the value of this complex function at any point with any precision I like, with finite memory, although unbounded - I need to allocate more memory when I want more precision.
Point is, I delay the process of "latticization" (calculating the numerical values at each point of a chosen lattice) to the very end - only then I have to choose how fine-grained my lattice is.
This is the error. All you have is some partial differential equation. It has no known symbolic solution.
So the thing we'd want is not continuous values but continuous registers. Maybe this is possible with some very clever engineering but I'd wager that your computation will develop other problems, such as thermal noise causing problems (whereas digital computers have error correction).
This quantity (g-2) is dominated by electrodynamic effects. The QCD contribution is on the scale of 1e-10 compared to the full result. But it is the leading theoretical uncertainty.
There are two ways to get a prediction for the QCD contribution to this process. One is to try to back it out of a variety of data from unrelated experiments. In other words: try to fit it by requiring consistency. The other is a LQCD calculation.
The experimental data-driven fit to the QCD contribution and the LQCD calculation differ significantly. This difference is the difference between the current experiment claiming a sizeable new physics effect (the data-driven approach) and perfect agreement with the Standard Model (LQCD calculation).
So there's an interesting puzzle!
Given some experimentally-measured observables (the pion mass, the kaon mass, etc. as long as you include 1 observable per parameter in QCD, meaning 1 gauge coupling + 1 per quark flavor you include in your simulation) you can calculate all other quantities---in a world that is pure QCD. We are now getting to an era where we can do lattice QCD+QED, but we cannot do lattice-standard-model because of the issue with chiral gauge theories mentioned in the article. However, since the weak sector is perturbative, we can combine pen-and-paper/Feynman-diagram-style calculations with LQCD calculations to get what we want: first-principles Standard Model predictions.
To discover new physics you need both an experimental signal and a precision prediction from the Standard Model. If they differ that difference is something not in the Standard Model.
What kinds of quantities can we calculate? The first major success was a calculation of the hadronic spectrum [spectrum]. We've also seen precision determinations of the QCD phase diagram (vacuum properties as a function of temperature) [phase diagram] and other properties that are important for the early universe, although there is a computational resources / scaling problem for nonzero density. With QED included there's a calculation of the proton-neutron mass splitting [mass splitting]. In terms of hadronic matrix elements we can compute the axial coupling of the neutron [gA], neutral kaon mixing, matrix elements needed for nuclear calculations of neutrinoless double beta decay [0vbb], all sorts of stuff. The FLAG review [flag] collects and evaluates individual results and tries to construct a community consensus for our "best values" for certain observables.
> Is it possible to state and solve initial value problem for, say, proton-proton scattering?
You picked one of the most difficult problems in lattice QCD (and one I spent a lot of time on as a postdoc): extracting baryon-baryon scattering. At high energy actually there is a lot of progress because QCD factorizes and you get a parton picture [PDFs]. But at low energy the situation is worse. There are a few issues:
1. We calculate in a finite box, typically with periodic boundary conditions (think PacMan). So there is no way to make protons "asymptotically far apart", and once they're heading apart, they're heading towards their next encounter. This conceptual difficulty was solved in the late 1980s: what you can do is take the energy of the finite-volume standing waves and turn that into phase shifts (quantum-mechanical scattering data).
2. Our calculations are done in Euclidean time, for reasons I have explained / touched on on hn before
https://news.ycombinator.com/item?id=15782932
https://news.ycombinator.com/item?id=23403883
So we don't have real Minkowski time; you can think: instead of things evolving like exp(i H t) things evolve like exp(- H t), where H is the Hamiltonian.
3. Baryons suffer from a signal-to-noise issue, where the longer we look in time the worse the variance gets. The source of this issue is understood and we have variational methods to get reliable signals earlier in time. The signal-to-noise problem is easier at heavier quark (or pion) masses (which we, as computational physicists can change even though experimentalists cannot).
For a long time we sharpened our tools at ~800 MeV pion masses. Current state of the art is down around 300 MeV.
This sounds dismal but I want to say: we have the whole pipeline working end-to-end. There are phenomenal results in the meson sector [meson scattering]. There's very-close-to-physical-parameters meson-baryon scattering [n-pi].
SO: is it possible to solve the initial value problem for proton-proton scattering using LQCD?
Not yet but work is in progress.
What these calculations give are phase shifts (and inelasticities) as a function of scattering momentum.
Once these are under control we can try to get a handle on the three-body sector; the three-body force is needed for accurate calculations in nuclear physics.
[spectrum] https://arxiv.org/abs/0906.3599 see especially figure 3
[phase diagram] https://arxiv.org/abs/1309.5258
[mass splitting] https://arxiv.org/abs/1406.4088
[gA] https://arxiv.org/abs/1805.12130
[0vbb] https://arxiv.org/abs/1805.02634
[flag] https://arxiv.org/abs/2111.09849
[PDFs] https://arxiv.org/abs/1711.07916 and a lot of progress has been made since then.
[meson scattering] https://arxiv.org/abs/1708.06667
A Turing machine can perform all discrete computations with a single bit. An idealized analog computer can compute anything with a "single" complex plane.
Our (mis)conception of there being an "infinite memory problem" when the complex plane is infinite is analogous to flatlanders getting hung up about a "discrete bit memory problem."
We are using a lot of low precision computations in graphics, neural networks, ....
Pi also can't be calculated exactly to infinite precision, yet that doesn't stop us to compute circles and so on.
You will run into this limit and it's a physical hard limit. Lookup why it's called quantum (mechanics, physics, field theory, etc).
Before you simulate an entire universe try accurately simulating one atom. Let me know how it goes (spoiler alert: the computing power needed to do this is beyond the computing power we have today)
> (...)
> You know, if you take this theorem at face value, it’s telling us we’re not living in the Matrix. The way you simulate anything on a computer is by first discretizing it and then simulating. And yet there’s a fundamental obstacle seemingly to discretizing the laws of physics as we know it. So we can’t simulate the laws of physics, but it means no one else can either. So if you really buy this theorem, then we’re not living in the Matrix.
I don't buy this reasoning.
I can encode the continuous function f(x) = x^2 on a computer. Then I can calculate this function for any number up to any digit, if I allocate enough memory.
I don't need to allocate a discrete domain up-front and then stick to it at all times. I can increase and decrease the accuracy as needed.
In a similar fashion I could simulate a continuous universe encoded with continuous operators. I could simulate it on a discrete lattice with certain precision as long as nobody inside the simulation builds equipment that can measure things "in-between" the lattice points. And when somebody does, at that moment, I can simply pause the simulation, calculate the values of my operators using a locally-denser lattice, then unpause. The observer with their equipment wouldn't notice anything because the simulation was paused, they would just get the correct measurement.