I’m also on Mastodon as https://hachyderm.io/@BoydStephenSmithJr .

  • 0 Posts
  • 4 Comments
Joined 3 years ago
cake
Cake day: October 2nd, 2023

help-circle

  • Honestly, I think CS research has hinted we were going in this direction anyway. Dependently-typed languages like Idris and Agda have as term-inference for a while, it was based on exhaustive type-directed heuristically-prioritized search but it could still auto-complete/fill some non-trivial code, and Roq tactics could also make things that were disastrously wordy read much more simply and they are effectively a form of compile-time function (Elaborator Reflection is probably a better approach, but Roq’s two-language model is much more well-established).

    Even without quite so interesting types, there were academic exercises like “Djinn” that could exhaustively enumerate lambda-calculus function bodies given the parametrically polymorphic type signature and a library of standard functions, and that’s been available for 14+ years? In an entirely different direction we’ve had SMT solvers can could be plugged in to a few languages to verify a LOT of properties that can be expressed in first-order logic.

    Still, I think there’s plenty of magic, it’s just not in the places we can lay down (enough) axioms around symbolic structure / grammars.


  • Probably some of both. Though, given the short history on these proofs, it will likely be more “slop” (or theft) than anything else.

    While this is orders of magnitude larger, the first 4-color theorem theorem had a lot of cases that were quick for a computer to exhaustively check. But, it turns out a lot of those cases are better explained without exhaustive checking, so the currently taught / best proof of the 4CT is shorter and has less long, mind-numbing checks.

    It’s entirely possible that there’s actually no more “insight” from the LLMs, and they were just better able to generate the massive type signatures and terms that Lean needs to begin mechanically checking, because they are able to generate and discard good syntax much faster. But, there might also be some interesting bits that people (or LLMs) will be able to extract/abstract/generalize/shrink into something humans will find insightful. I think the Navier-Stokes related proof did have some stuff in it that humans found interesting beyond the final result.


  • They used 2 checkers that are maintained and developed independently of the Lean kernel. But they did use Lean formats/syntax. They’ve also done some manual verification, though there might be more to do. The proof did use the statement if RH directly from the well established Mathlib.

    I’ve also seen claims that the proof has some weird things in it that might be hints that it is finding holes in the theory Lean models.

    Honestly, even if it ends up not being a proof of RH, it will tell us something about computable / constructive maths.