Hacker News Reader

Comment by dmbaggett | Hacker News Reader

I’m curious: could anyone knowledgeable share a bit about these QCD lattice models — are they incredibly complicated? Are there open source implementations of these models and if so, would the code make any sense to a non-physicist programmer?

View on HN

> are they incredibly complicated?

That depends on what you mean by "complicated". Conceptually they are not too bad, it's basically just quantum field theory (which some might consider "incredibly complicated" so YMMV). But the devil is in the details. From the article:

"While physicists know the exact equation that defines the strong force — the fundamental force that binds quarks together to make the protons and neutrons in the hearts of atoms, as well as other composite particles like tetraquarks — they can rarely solve this strange, endlessly iterative equation, so they struggle to predict the strong force’s effects."

> Are there open source implementations of these models

That I don't know.

> and if so, would the code make any sense to a non-physicist programmer?

Having seen code written by scientists, I can confidently answer this with: almost certainly not.

>Having seen code written by scientists, I can confidently answer this with: almost certainly not.

Got a kick out of that, thanks. I think there is a kind of compartmentalization of environments going on when one engages in scientific programming. It seems to often be structured more akin to math than code. I once worked with a brilliant multitalented individual who held a PhD in a specific field of physics that I cannot recall. In one instance they ported the orchestration software for a supercomputer from python into java, in a week. It was beautiful to read. This same person used single letter variables in their ML models and had virtually zero comments which made it somewhat difficult for me to follow their updates after a week of having not seen the code.

To me, it's a difference in professional gestalts(?) in highly trained individuals.

Physical engineers, especially, have a very formalized, standardized way of looking at the world. They all share it, and so their code follows from that.

Physicists, biologists, software developers all have different ways of looking at the world (some more standardized, some less). Our code follows from that.

So while we may gripe they don't leverage (insert language arcana / convention), my intuition is our code would still look very different even if they did. Biggest example, as you point out: math-structured code, from math-heavy disciplines.

Here's an analogy that I can speak from more direct experience: if you study the theory of elliptic curves, and then look at elliptic curve cryptography code, there will appear to be no connection between the two. This is because in between the theory and the code are a zillion implementation details and tricks of the trade that aren't generally mentioned in the theory. Add to that the fact that the people who write scientific code aren't coders by trade, so they learn to write code that is just good enough but no better, and the result is something that looks like a horrible mess. (Also, the code is often written by grad students, so that makes it even worse. I look back on some of the code that I wrote back when I was a grad student that was the basis for publications and I shudder.)

This reminded me of the chemical PhD who created Clasp, a full common lisp implementation using LLVM as a JIT compiler, able to call even template C++ code from Common Lisp (a feat which no other language I know of even tries, except perhaps .NET with managed C++).

[0] https://github.com/clasp-developers/clasp

From what I’ve heard the core of the issue is it’s similar to non-online game development. Most scientists make some programs for a single paper, and then just start from scratch for a new project. When you don’t have to care about long term maintainability readability becomes much less of a concern to people.

The Fortran code at particle research groups I saw looked pretty solid to me.

"Fortran" and "solid" are not two words that go together in my mind ;-)

But the OP didn't ask if the code was good (or "solid"), they asked if it would make any sense to a non-physicist programmer. And the answer to that question, I'm guessing, is most likely not. But I would be very happy if I turned out to be wrong about that.

It probably boils down to if there are any non physicist Fortran programmers...

You can write bad code in any language. The verbosity and restrictions of (modern) Fortran standards leave significantly less room for developer mistakes, much better than C/C++.

I’m a LQCD practitioner.

There are a variety of open-source implementations; I’ll just point to a few. The one funded by the Department of Energy through the SciDAC program is the USQCD software stack [0]. There’s also the GPU library quda, which is maintained by Nvidia employees (and others in the community). There’s Grid [2], development led by Edinburgh in close collaboration with intel (to make sure it compiles down to sensible high-performance primatives). There’s openQCD [3], coordinated by CERN researchers.

As to whether it’ll be readable to you—-maybe? How transparent each library is differs. The most important parts are typically (1) the generation of gauge configurations (typically by HMC, which was discovered by the LQCD community [4]), which are MCMC samples and (2) the calculation of observable on each sample. Both rely on highly optimized (and preconditioned, and maybe multigrid-ed) linear solves—-the most important kernel.

Some libraries are written to be as transparent as possible; some to be as portable as possible. All are written to handle massive data parallelism across hundreds of high-performance nodes with some mixture of OpenMP, MPI, #pragma acceleration, etc.

Finally, the code will only “make (big picture) sense” to you if you understand lattice quantum field theory.

[0] http://usqcd-software.github.io/ [1] http://lattice.github.io/quda/ [2] https://github.com/paboyle/Grid [3] https://luscher.web.cern.ch/luscher/openQCD/ [4] https://www.sciencedirect.com/science/article/abs/pii/037026...

I'm not an expert on particle physics, but the verbiage sounds to me like one of the standard problems in physics: We can write the differential equations. But even simple differential equations can be unsolvable. For example, consider the simple Three Body Problem. The differential equations are simple enough that you can use them as an introduction to the concept of differential equations themselves, but the Three Body Problem is not in general solvable.

The three body problem can generally be acceptably approximated for a reasonable period of time. But that problem only involves inverse squaring of distances. Strong forces decay much faster than that, which makes them more sensitive to errors. Plus you end up with one of the fundamental problems we have trying to understand our universe, which is just how monstrously enormous and monstrously slow we humans are. We operate at "meter" scales and "second" time frames, and particle physics operates at somewhere around 30 and 40 orders of magnitude smaller, respectively. (Not quite all the way down to the Planck sizes, but closer to those than to the macroscopic world.) So when you try to numerically approximate the differential equations, you don't get very far in time or space before your approximations have critically diverged from reality.

It's like we're trying to work out the fundamentals of chemistry and our primary tool is smashing planets together.

When people say that the three-body problem is "unsolvable" they really mean that there's not a way to write out an analytic solution to the problem. In the same way, you can call quintic polynomials "unsolvable", because there's no way to take arbitrary quintic polynomial equations and express the solutions as ordinary algebraic formulas.

However, it's very misleading to call quintic equations unsolvable, because we know where the solutions are, and we can use various numeric methods to calculate the solution with arbitrary precision. Any time we can calculate the answer with as much precision as we want, I'd like to say that the problem is "solved" in a very real and meaningful way.

The problem is worse with quantum mechanics. With quantum mechanics, not only do we lack analytic solutions to many of the equations used in QM, but we also lack good numeric solutions (using real hardware, at least).

Following the analogy, as a layperson, what's the nature of the difference with quantum mechanics that doesn't allow it to be solved to arbitrary precision (even if through brute force iteration)?

Is it that we haven't discovered the solution generating algorithms? That the state/probabilities of quantum mechanics are fundamentally untenable to similar calculation? Or something else entirely?

It's nothing fundamental, as far as I am aware. Depends on what you mean by "fundamental".

There is no known way to simulate a quantum computer, using a classical computer, in polynomial time. A quantum computer is just a kind of quantum system, so we know that some quantum systems cannot be efficiently modeled (barring revolutionary advances in simulation algorithms).

When your simulations take superpolynomial time, it tends to be easy to find problems which you simply do not have the computational resources to solve, and you may not be able to solve interesting versions of the problem. There are lots of examples of problems like this. However, I don't consider this to be a fundamental difference.

For example, satellite navigation systems are just fine calculating directions for driving all the way across the continental US, even though that's a very "large" instance of the problem that they are solving. But if you try to find the fastest route for a delivery driver to make a hundred deliveries within one city, good luck. This is just an analogy, and I'd like to emphasize that "no KNOWN algorithm" efficiently solves these problems, and that we haven't proven whether such an algorithm exists.

Thanks! By "fundamental," I was curious about the nature of the problem's difficulty, moreso than the progress on solutions. And computational intractability due to system properties makes sense!

Also a layperson, but as I understand it. We do have the algorithms to simulate quantum systems with n states to arbitrary precision through brute force. But they require that you can put ~n bits into a superposition state.

If your computer doesn't have that capability, you can simulate it to arbitrary precision with ~2^n bits.

Many problems in physics are perturbative. Then, approximate methods suffice to get reliable answers. In Asimov’s “relativity of wrong” it’s the perturbative nature of gravity—-gravity is very weak—-that makes “the Earth is a sphere” less wrong than “the Earth is flat”. So, if you need an answer to only such-and-such precision, the approximation scheme lets me know how hard I must work to achieve reliability at that scale. Once I get the precision I need I can stop.

Electrodynamics is like that. There is a number, the fine structure constant, about 1/137, that gives the natural scale for how big the next step in the approximation is, compared to the size of the current step. So, if I need to know the answer to 1 part in 10^9, I’m going to need to do 4 or 5 steps of fixing up the approximation (each fix, of course, being a great deal more arduous).

QCD, and other “strongly coupled” or “non-perturbative” problems are not like that. If you make the dumbest approximation (flat-earth) and then fix it up a bit (sphere earth), answers don’t change just a little. They change completely. In QCD the number that characterizes the “obvious” approximation (the Feynman diagram approach)—-the number that’s 1/137 for electrodynamics—-is about 1.5. That’s a disaster! The approximation scheme is obviously no good—-you learn that you can never stop improving your approximation, because if you only worked “a little harder” your answer could change completely.

Other approaches are required.

Well put, though one nitpick: the three body problem is solved. It illustrates another case: even if a solution is known, it might not be practical.

https://www.math.uvic.ca/faculty/diacu/diacuNbody.pdf

> Are there open source implementations of these models

there are some open source packages for lattice QCD. e.g. https://jeffersonlab.github.io/chroma/

Also found this GitHub topic page: https://github.com/topics/lattice-qcd

Goodness me, that's a blast from my very distant past! The venerable MILC code is still available: https://web.physics.utah.edu/~detar/milc/milc_qcd.html

As far as I recall, QCD gives you a nice simple formula - a path integral over quantum operators - for any quantity you want. Lattice QCD works out the answer with great big Monte-Carlo integration. The tricky bit is defining a field theory on a finite discrete space-time lattice that is provably equivalent to the continuum theory after controlled extrapolations to the continuum. And you have to show that you can define the correct operators in the lattice theory that really do give the quantities you want. Then you need to implement this in code that runs blazingly fast over huge data sets. These considerations, and the fact that there are all sorts of solutions to these problems which might supported by a code base, tend to make code implementations complicated.

A Quick search found this: https://github.com/akio-tomiya/LatticeQCD.jl

Not my field of expertise though, I am in experimental gamma-ray astronomy

I've wondered this too, and if it's possible for a toy implementation to help teach the concepts, but I suspect not. Probably the translation to code obscures more than it illustrates.

You might enjoy Lepage’s “Lattice QCD for novices” which develops a lot of the ideas without getting bogged down in the specifics of QCD (it focuses on the harmonic oscillator + a harmonic oscillator).

[0] https://arxiv.org/abs/hep-lat/0506036

Reply on news.ycombinator.com