𝙳☈ retweeted
oh. next fields medal(s) aren't until 2030
thinking about what math might be like in 2030 seems like trying to imagine 21st century warfare from idk say circa the hundred years war
𝙳☈ retweeted
i think mathematicians should be pulling up the proof and working together with AI to understand it and its implications.
When I interviewed Terry Tao in March of this year, I asked him about AI solving the Riemann hypothesis. Here's what he said:
"Part of the reason we prize problems like the Riemann hypothesis is that we’re pretty sure a new type of mathematics has to be created.
We don’t even know what the shape of the solution is, but it doesn’t feel like a problem that will be solved just by exhaustively checking cases."
𝙳☈ retweeted
If the Generalized Riemann Hypothesis (the stronger version of the Riemann Hypothesis) is proven, these become proven facts:
Algorithms that no longer need randomness
- Primality testing: Miller's fast test becomes proven correct with no randomness
- Square roots mod a prime: becomes solvable fast and with no coin flips (today that's an open problem)
- Cube roots and other roots mod a prime: same.
- Factoring polynomials over finite fields: almost fast (quasi-polynomial) with no randomness, instead of needing randomness
- Building finite fields: you can construct any finite field directly, with no random search
- Factoring vs. φ(n): factoring a number becomes provably as easy as computing φ(n), even without randomness
- Primes with a given remainder: a prime with any allowed remainder mod q exists that's at most about q², so searching for one is fast
Complexity theory
- Polynomial equations: "does this system of equations have a solution?" drops from PSPACE to a much lower class (AM)
- Algebraic P vs NP: Valiant's algebraic version of P vs NP gets tied to the normal P vs NP over the complex numbers
- Turing machines: a known 744-state Turing machine is proven to run forever
Number theory software
- Math libraries: PARI/GP and Magma results computed "assuming GRH" become fully proven
- Class groups: algorithms that compute these number-field structures get guaranteed running times
- Elliptic curve generation: the algorithms used to create curves for crypto get guaranteed running times
Cryptography (no new attacks, only proofs)
- Elliptic curves: proven that if discrete log is hard on one curve, it's hard on almost all similar curves
- Lattice crypto: known quantum attacks on some lattice schemes become proven to work
- Isogeny crypto: known quantum attacks on some isogeny schemes get proven speeds
- Code-based crypto: schemes like BIKE get the guarantee that the special primes they need exist
Prime gaps
- Next prime: there's always one within about √p·log p of p, so "find the next prime" has a guaranteed worst case
What it does NOT do
- It doesn't solve P vs NP
- It doesn't make factoring easy, so RSA and elliptic-curve crypto stay safe
- It doesn't make anything faster in practice, because randomized versions already work today
- Ramanujan graphs, expanders and AG codes are unaffected: they use a finite-field version of RH that was proven decades ago
𝙳☈ retweeted
I quantized inkling 2 mini down to 5.4GB and 8.9GB versions, retaining 91.2% and 96.8% of original performance. fast drafter and iphone version coming soon. link below.
𝙳☈ retweeted
this should have more attention than it's getting
Jeveration: a model that generates a 512 × 512 image in just 78 ms!
A frozen vision-language model returns a whole 512 px image as one decision, in a single forward pass.
Jeveration: System One Models Now Generate. arxiv.org/abs/2611.24738
- Try the demo:
huggingface.co/spaces/linlin…
𝙳☈ retweeted
Oh, hell fucking yes. Hell yes. We might make it.
Huh. Inkling 2 is a much weirder model than I thought.
In addition to being looped (yeah yeah doom whatever), it uses a positional encoding I haven't seen before: a combination of a 4-tap learned convolution (who knows what it's doing?) over recent KVs and a learned hidden-state-depenent (so for first layer, token indexed) boost to KQ scores for each position in the sequence.
I'm curious what the latter ends up being in token space. Say current token is "the". That's the whole first layer "hidden" state. Which sequence positions get boosted? Do we see longer or shorter range attraction for, e.g. prepositions? What about "former" vs "latter"?
I expect the hidden layers to be noninterpretable here, but the first couple of layers you might be able to just read off the weights.
Also, of course, everything else uses this "learn an index function" pattern, e.g. using Kimi's block attention residuals to dynamically select which parts of a residual stream to emphasize.
The looping itself is also interesting. It's not just virtual layers that happen to have tied weights. (That's the naive approach.) They instead all start with the pre-skip hidden state and have a special loop-specific d_model-wide message channel from previous loop to the next. The connection is (unlike regular residual attention) strictly Markov with depth 1: loop N reads ONLY from a) pre-loop prelude and b) loop N-1's side channel. That's what lets it loop a variable number of times, I guess.
Anyway, all in all, seems like a cleverly constructed compact model in which basically everything is grouped and pooled and gated by learned regulators to make sure information is used judiciously instead of being brute-force broadcast everywhere and masked out where not needed.
The model is remarkably *anti*-bitter-pilled in that it's chock full of explicit architecture instead of "add more layers; let model learn to use them" minimalism. It seems to work very well for this heresy.
(BTW: anyone try LoopVQ or other clever cross-loop KV compression tricks with this yet? Haven't looked.)
𝙳☈ retweeted
Every LLM API is built wrong. REST, WebSockets, all of it. The solution was in front of us the entire time. DNS literally has a Question section and an Answer section. Cloudflare Workers can accept direct TCP connections now, so here is LLM via DNS:
dig +tcp +short @ask.southpolesteve.com what-is-a-websocket.ask.sout… TXT
Replying to @Tom62589172
If folks are suspecting a lean bug in the proposed GRH proof, for example, porting it to coq and rechecking it there should add confidence.
Holeee sheet.
(I’m assigning >50% likelihood that this is legit).
Levent Alpoge @__alpoge__ claims to have proved RH and GRH with Claude (!!)
alpo.ge/remark.pdf
𝙳☈ retweeted
Neurons are fascinating entities--often weirdly specific, at other times representing concepts we might not even have words for. We made an atlas of all 5M neurons in Qwen 3.6 35B--check them out for yourself!
A language model is a wonderland of strangely specific neurons, from gargling to comic exasperation to the moment a guard looks away.
We made a searchable atlas of all 10 million neuron poles in Qwen3.6.
Play with it here: goodfire.com/research/public…
𝙳☈ retweeted
the future of mech interp. abstracting functional mechanisms from their particular instantations. we are, after all, in search of learned algorithms, not merely the circuits that implement them.
Train the same AI 3 times. Same behavior, different circuits.
So is a circuit the algorithm—or just one implementation of it?
Meet ACE: a new way to understand AI. It extracts what different wirings share—to explain why AIs grok and to steer LLMs up to 32B 🧵
#NeurIPS2026
𝙳☈ retweeted
Compression is one of the more recognizable things that intelligence *does*, given it leaves obvious breadcrumbs.
Those of you who’ve followed know that I see compression as intimately bound up with intelligence, given my generalization of transformer-based LLMs to the domain of holographic compression.
Still, compression *does not* exhaust the process toward which “intelligence” gestures.
It’s a tempting view, but will ultimately leave you equating organismic navigation of open systems with closed-form deterministic equations.
Predictable for a math communicator, but fatal when applied reflexively to our own image.
𝙳☈ retweeted
My Bend2 talk @ SF Lean Meetup is up:
youtube.com/watch?v=PqufdZ5s…
It explains my rationale behind the language design
Thanks everyone for being so kind there, that was unexpected, and sorry for mishearing some questions, I want to go back and become fluent in English
asking the right question will get us far more ahead than finding the right answers.
We design objects from first principles. That starts with asking the right question.
A heat exchanger must transfer heat from one fluid to another. So the question is not: What should a heat exchanger look like? It is: How can two fluid streams pass close to each other, expose as much heat-transfer area as possible, and fit within a compact volume?
Noyron begins by modeling the fluid paths. It then derives the solid geometry by offsetting the fluid domains outward and subtracting the original fluid volumes. The surrounding shell and channels emerge from the required flow.
Many of the organic-looking objects we build are created this way. Start with how a gas or liquid needs to move through a system, then derive the vessel around it.
Do not design a pipe. Design a fluid flowing through space.































