Finite simple groups are building blocks of finite groups, like primes are for whole numbers.
The “Enormous Theorem” states that every finite simple group belongs to one of the known infinite families or is one of 26 sporadic groups, including the Monster.
There are no others.
We’re releasing a broad range of new mathematical results produced by an internal frontier model.
We’ve been consulting with the independent Advisory Group on Mathematics and Artificial Intelligence at the Institute for Advanced Study, and we have drawn on their advice and public recommendations to inform how we release these results.
https://t.co/7N6TPlft1P
Navier-Stokes Millennium saga continues. Here are my slides and a summary from a recent talk. Disclaimer: this is a physicists view of the problem & solution! 🧵
I've asked Astra to read the DeepSeek v4.1 Flash paper and compare it to the original Transformer architecture in 3D - you can zoom in an inspect each element side by side. Things have changed quite a bit.
Try yourself: https://t.co/ESxu7fYGlG
We are focusing on understanding this model, and using what we learn to help us guide and pace how we pursue further advances in capability.
Our goal is to build AI systems which are steerable, accountable, and connected to people, which may require more deliberate choices about the pace of progress, as we continue our mission to ensure AGI benefits all of humanity.
https://t.co/jJdfTOSCvu
I’m using pi much more for long-horizon tasks (>6h). it's simpler by design and easier to work programmatically. i rarely use pi tui, most of my work is driving it inside a bigger system/container/uiux. some takes:
- pi ships with a minimal toolset and it's enough for airgapped tasks. if you have enterprise customers who want everything airgapped, pi + open-weight models is the goto solution.
- pi extensions are mostly unnecessary. i only have pi-mcp-adapter and pi-vcc installed, because i need to maintain/use jina reader mcp. pi-vcc is a drop-in fix for pi's context compaction, which can bite you on long-horizon tasks (see screenshot last swimline where compaction takes more and more time in long-horizon task)
- no double-dip: if you program pi with an agent like CC/Codex, you'll likely end up building another harness layer on top of pi's own harness, completely redundant glue code. every now and then you need to steer CC/Codex back to pi's design principle: keep the wrapper lean and mean, use pi native features as much as possible.
- imo pi works best with open-weight and self-hosted models, or at least that's what makes pi fun to work with. But pay attention to pi/models.json: your coding agent probably doesn't know every attribute of those new open models. forget to declare image modality as an accepted input and pi suddenly starts shelling out to tesseract for ocr everything. Or leave max context length conservatively set at 65K and pi starts compacting frequently for no reason.
- in the end, the nudge prompt (the one that keeps pi going forever), and workspace isolation (for multi-task/multi-tenant systems) are where you'll actually spend your effort. Not too many but that’s fine and that’s the point, for the harness just trusts pi to do the work in a very first-principled way. You can just focus on the actual task.
A little video that
- explains the relationship between conventional LLMs and reasoning models (and agents),
- philosophizes a about "from scratch" approaches,
- and explains how to install Python & PyTorch requirements with uv.
We ran the largest open experiment on how frontier models do AI research.
100+ autonomous runs across 10+ models, sandboxed on 8xH200s for up to 8 days, iterating on the nanoGPT optimizer track.
Best runs closed 82% of the gap to a record built by dozens of humans over months.
When the Sun is overhead, its light passes through a relatively short layer of air. Near sunset, that same light must travel through a much longer atmospheric path. Along the way, air molecules scatter short wavelengths (blue and violet) far more efficiently than long wavelengths (red and orange) as a consequence of Rayleigh scattering, which scales roughly as 1/λ⁴.
By the time the light reaches you, much of the blue has been scattered away from the direct beam, leaving sunlight enriched in warm oranges and reds. The beautiful colors of sunset are really a visible record of light interacting with Earth's atmosphere.
We're starting to leave the territory where you'd test an LLM by e.g. "create an svg of pelican on a bicycle". As one idea to generalize it, I was interested what Opus 5 would do if I gave it the first paragraph of the Lord of the Rings, a 1M token budget (~$10) and asked for three js render of it. Opus went off for ~2 hours and wrote 5500 lines of code that (procedurally) rendered the story. It's kind of janky but fun. But it's a bit mindboggling that the LLM has to place and orchestrate various polygon assets in (x,y,z) coordinates and write code that animates it all, and that it even does anything at all.
I also like this kind of examples because no one in their right mind would ever spend the time to write something this custom but LLMs have all the stamina and patience in the world, so it's an example where we go from "no one would ever do this" to "sure, why not, it's ~free". There might be a lot more. But I'm excited about creating hyper custom worlds that you can imagine dropping players into, e.g. here to participate in the LoTR story as a spectator NPC, or one of the characters, or etc. Something like an ephemeral GTA of X on demand.
Last thought is that the domain of worlds/games exposes a weakness in LLMs: they can't easily audit their work because they aren't able to efficiently and natively perceive videos or play games within them. Here, Opus 5 had to very slowly and painstakingly take screenshots at different points, and it messed up a few times and created a bunch of jank. An example of raw capability (multimodal, gameplay) that I think is still quite lacking.