frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

Levent Alpöge claims proof of the Generalized Riemann Hypothesis [pdf]

https://alpo.ge/remark.pdf
1678•iamronaldo•4h ago•1147 comments

Language Models Can Rewrite Their Own Weights

https://arxiv.org/abs/2611.21885
182•lwhsiao•2h ago•81 comments

I'll never buy Framework hardware again

https://poolp.org/posts/2026-11-20/ill-never-buy-framework-hardware-again/
584•unchar1•2h ago•377 comments

Finite-time blow-up for the Navier–Stokes equations

https://github.com/tristanbuckmaster/navier-stokes/
145•trotro•3h ago•38 comments

Unforced Navier-Stokes Singularity and the Generalized Riemann Hypothesis

https://terrytao.wordpress.com/2026/11/20/unforced-euler-singularity-unforced-navier-stokes-singu...
43•archon1410•1h ago•2 comments

If you can't explain something in simple terms, you don't understand it (2017)

https://kottke.org/17/06/if-you-cant-explain-something-in-simple-terms-you-dont-understand-it
484•sammatilda•8h ago•253 comments

Frostbite: A new CPU architecture discovered, designed and verified by AI

https://architectlabs.com/blog/frostbite
499•shioyama•8h ago•278 comments

I'm Peter Roberts, immigration attorney who does work for YC and startups. AMA

43•proberts•1h ago•60 comments

Signal Is Serious About Protecting Your Privacy

https://signal.org/blog/protecting-your-privacy/
310•dotcoma•9h ago•186 comments

Running two PSP emulators on one Switch 2 and sharing one via GameShare

https://github.com/XITRIX/ppsspp-nx2/blob/master/SWITCH2-GAMESHARE.md
19•khalidkhair•1h ago•0 comments

Show HN: I made an audio-to-MIDI model 60x more efficient

https://kobi.music/research/dettato
166•hidude562•3d ago•31 comments

We promoted developers into architects without informing them

https://manidoraisamy.com/developer-to-architect.html
8•QueensGambit•25m ago•1 comments

Why YC Series A rounds fell off a cliff

https://jaredheyman.medium.com/on-why-yc-series-a-rounds-fell-off-a-cliff-ab523211a2f2
37•redm•2d ago•10 comments

Google Workers Tell Their Employer Not to Punish Schools That Don't Want AI

https://www.motherjones.com/politics/2026/11/google-alphabet-union-school-ai-protest-gemini-worke...
68•cdrnsf•1h ago•14 comments

PostgreSQL 19: A hands-on tour with runnable browser examples

https://certuvia.com/blog/postgres-19
15•petrpravda•1h ago•1 comments

Vibecoding an Inference Chip

https://ankitg.me/blog/vibecoding-inference-chip/
4•ankitvgupta•28m ago•0 comments

Why there are still no non-WebKit browsers on iOS

https://blog.mozilla.org/en/mozilla/internet-policy/apple-ios-browser-engine-rules/
213•lapcat•3h ago•105 comments

Floppy3.5: A portable 3.5-inch floppy WiFi NAS

https://github.com/bigcrimping/floppy3.5
101•fortran77•1d ago•46 comments

The G1 Garbage Collector

https://dev.java/learn/jvm/tool/garbage-collection/g1gc-overview/
64•ejboy•3d ago•16 comments

The Making of Oxygene

https://jeanmicheljarre.com/aaa/the-making-of-oxygene
158•hggh•8h ago•61 comments

Anthropic shares tank after IPO as the Nasdaq erases 2026 gains

https://www.nbcnews.com/business/markets/anthropic-shares-markets-selloff-nasdaq-rcna610394
52•lelanthran•59m ago•24 comments

Lovable: Now you can explore any idea in parallel without touching what's live

https://lovable.dev/blog/introducing-drafts
19•doener•3d ago•12 comments

Show HN: Fast deterministic natural language search for OpenStreetMap data

https://hippomaps.ch/?q=cafes+by+the+Limmat+100+m+from+the+lake+in+zurich#map=15.02/47.36708/8.54935
103•vihren•1d ago•30 comments

What people are building, discovered through new domains

https://startups.novumsignals.com/
128•walterschnitzel•8h ago•63 comments

OpenSSL: Buffer overflow in EVP_EncodeBlock() (CVE-2026-121481, CVSS 9.8)

https://github.com/openssl/openssl/pull/33652
350•JacobHenner•16h ago•306 comments

If you stop writing code, you also get worse at reviewing it

https://cekrem.github.io/posts/if-you-stop-writing-code-you-also-get-worse-at-reviewing-it/
234•theanonymousone•6h ago•118 comments

Carnival Cruises emits ten times more sulphur oxide than all of Europe's cars (2019)

https://ecohustler.com/article/one-corporation-to-pollute-them-all/
440•sammatilda•9h ago•270 comments

FFmpeg 9.1 'Gauss'

https://ffmpeg.org/download.html#release_9.1
268•gyan•14h ago•35 comments

µ-Wire – USB on an ATtiny 10

https://cpldcpu.com/2014/03/19/%c2%b5-wire-usb-on-an-attiny-10/
105•mofosyne•2d ago•17 comments

Claude solves two open problems in the physics of black holes

https://www.anthropic.com/research/claude-black-hole-physics
543•cybermango•1d ago•261 comments
Open in hackernews

Adventures in Symbolic Algebra with Model Context Protocol

https://www.stephendiehl.com/posts/computer_algebra_mcp/
121•freediver•1y ago

Comments

behnamoh•1y ago
So, we’ve come full circle to symbolic AI! This article essentially suggests that LLMs could be effective translators of our requests to command-line code or input to symbolic AI software, which would then yield precise solutions. However, I feel this approach is overly mechanical, and I don’t believe AGI would be achieved by creating thousands, if not millions, of MCP servers on our machines. This is especially true because MCP lacks scalability, and anyone who has had to send more than three or four function schemas to a language model knows that excessive JSON schema complexity confuses the model and reduces its performance.
pona-a•1y ago
I'm reminded of what happened in the later years of Cyc. They found their logical framework didn't address certain common problems, so they kept adding specialized hard-coded solutions in Lisp. LLMs are headed for AI autumn.
godelski•1y ago
I think the problem here is we keep making promises we can't keep. It causes us to put too many eggs in one bakery, ironically frequently preventing us from filling in those gaps. We'd make much more progress without the railroading.

There's only so much money but come on, we're dumping trillions into highly saturated research directions where several already well funded organizations have years worth of a head start. You can't tell me that there's enough money to throw at another dozen OpenAI competitors and another dozen CoPilot competitors but we don't have enough for a handful of alternative paradigms that already show promise but will struggle to grow without funding. These are not only much cheaper investments but much less risky then betting on a scrappy startup being the top dog at their own game.

ogogmad•1y ago
The article also suggests that you could use a proof-verifier like Lean instead. Using that capability to generate synthetic data on which to train helps too. Very large context windows have been known to help with programming, and should help with mathematical reasoning too. None of this gives you AGI, I suppose, but the important thing is it makes LLMs more reliable at mathematics.

Anyone have a link to an article exploring Lean plus MCP? EDIT: Here's a recent Arxiv paper: https://arxiv.org/abs/2404.12534v2, the keyword is "neural theorem proving"

I've just remembered: AlphaEvolve showed that LLMs can design their own "learning curricula", to help train themselves to do better at reasoning tasks. I recall these involve the AI suggesting problems that have the right amount of difficulty to be useful to train on.

I'll ramble a tiny bit more: Anybody who learns maths comes to understand that it helps to understand the "guts" of how things work. It helps to see proofs, write proofs, do homework, challenge yourself with puzzles, etc. I wouldn't be surprised if the same thing were true for LLMs. As such, I think having the LLM call out to symbolic solvers could ultimately undermine their intelligence - but using Lean to ensure rigour probably helps.

bwfan123•1y ago
We've come back full-circle to precise and "narrow interfaces".

Long story short, it is great when humans interact with LLMs for imprecise queries, because, we can ascribe meaning to LLM output. But for precise queries, the human, or the LLM needs to speak a narrow interface to another machine.

Precision requires formalism, as what we mean by precise involves symbolism and operational definition. Where the genius of the human brain lies (and which is not yet captured in LLMs) is the insight and understanding of what it means to precisely model a world via symbolism - ie, the place where symbolism originates. As an example, humans operationally and precisely model the shared experience of "space" using the symbolism and theory of euclidean geometry.

arunbahl•1y ago
Awesome stuff! We use a similar approach (without MCP) to great effect with Prolog currently and feels like we're only just starting to scratch the surface here.

A great paper from Nasim Borazjanizadeh and Steven Piantadosi at UC Berkeley for those interested: Reliable Reasoning Beyond Natural Language https://arxiv.org/abs/2407.11373

For anyone digging in who wants to hack on this: arun [at] aloe.inc

tpurves•1y ago
Wonderfully cheeky but also helpfully informative writeup. Also appreciate the hat-tip to all the (as yet) unsolved security issues. Clearly MCP is onto something important, although undoubtedly the standard (or some replacement standard) will mature a fair bit before we're done with it. The flip side to that is, MCPs are probably as 'easier' to experiment with now than they are ever going to be.
ash-ali•1y ago
I think this is the proper way to use llms for tasks that require high fidelity. currently im working on binary analysis using llms for natural language and letting ghidra/codeql do the symbolic work. scalability is a massive issue, perhaps the biggest besides fidelity.

its interesting to see many people come to the same neuro-symbolic conclusion around the same time.

amelius•1y ago
How does the LLM know that it can use the factor tool to factor integers? Just by looking at the string "factor an integer"?
manojlds•1y ago
Yup

this is what the tools response for the mcp server looks like:

{ tools: [ 0: { name: "factor" description: "Factor an integer" inputSchema: { ... } 4 items } ] }

snek_case•1y ago
They give it a list of tool commands it can use in the context I believe.
svat•1y ago
Yes, and I believe this is what the article is referring to when it says “a stochastic black box that communicates through a complex web of JSON schemas attached to docstring annotations”. Specifically, in the function definition:

    @mcp.tool()
    def factor(a: int) -> int:
        """Factor an integer"""
        return factor_number(a)
the decorator `@mcp.tool()` does something behind the scenes to set up the right thing using the docstring of the function.

The documentation and source code seem to be:

- (official SDK): https://github.com/modelcontextprotocol/python-sdk/blob/e80c... -> using the function's docstring: https://github.com/modelcontextprotocol/python-sdk/blob/e80c...

- (v2?): https://gofastmcp.com/servers/tools#the-%40tool-decorator and https://github.com/jlowin/fastmcp/blob/998de22a6e76fc8ae323e... -> using the function's docstring: https://github.com/jlowin/fastmcp/blob/998de22a6e76fc8ae323e...

rjeli•1y ago
the implementations have a distinctly "I wrote this at a 3 AM hackathon" vibe

The LLM handles the natural language interaction and orchestration, while the computer algebra system does what it does best ... exact symbolic manipulation.

this smells like claude :D

jgalt212•1y ago
> But let's not let a potential rootkit get in the way of a fun weekend experiment.

Great quote.

FilosofumRex•1y ago

  > So, we’ve come full circle to symbolic AI!
Yes, but from a business point of view, NLP based GUIs have been the holy grail of marketing and customer support, especially in STEM apps market.

Case in point, Wolfram Alpha is not much more than an attempt to market Mathematica to lazy and failing college students. If that cost, and localization, can be offloaded to LLMs as the universal front end to technical software, it'd free up SWE resources to focus on core functionality.

If Magma, my favorite math/cryptography tool, had an LLM frontend, I could save time wasted onboarding new cryptographers.

https://magma.maths.usyd.edu.au/calc/

Iwan-Zotow•1y ago
Curious if this could be done for Mathematica. SymPy is kind of ...
georgearvanitis•1y ago
Live CEOing Ep 910: Design Review for MCP Server Paclet[0] posted yesterday
Hugsun•1y ago
I was very pleased to discover that Mistral's Le Chat has inbuilt support for python code execution and sympy is importable.

It will regularly use it and reliably when asked to.

crystal_revenge•1y ago
I really appreciate Stephen's mixture of skepticism combined with genuine interest in experimenting with these tools. Most MCP posts I've read have been so much hype I've been left with no clue what MCP actually does. This is the first article I've read on the topic that earnestly makes me want to start messing around with MCP for fun (and makes it clear how to get started).

It's a bit unfortunate that the field is so dominated by extremes of hype and skepticism, both of which aren't particularly helpful to getting problems really solved.

beastman82•1y ago
It's just good writing. Funny, insightful, detailed.
mhh__•1y ago
I like this type of flow.

On tensor notation: Tensor indices aren't bad (a good notation should guide a calculation and they do) but I can't help but feel they're far too error prone.

What are the alternatives? Penrose diagrams?

ogogmad•1y ago
Abstract index notation. It's completely different!
0cf8612b2e1e•1y ago
Tangentially, are there any symbolic algebra systems that can handle millions of equations?

I have never used a symbolic algebra system, but came across a problem where I am trying to model a deterministic simulation system. I can write out the computation graph (~20 million equations for final state), but Sympy chokes on seemingly dozens of symbols. No hope of processing the final state or being able to express a simulation state in terms of my desired input variables.

Not sure if my expectations are mismatched with reality, I am hugely bungling the tool, or Sympy has laughable performance vs the more capable commercial options.

6gvONxR4sf7o•1y ago
Presumably if you have 20 million equations, they came from a program that's has fewer than 20 million moving parts, like if they came from A x = b where the matrix A has 20M entries. The gist is either exploit structure to make a massive number of small equations or keep the symbols in their "natural" form instead of reducing to scalars, and work with more advanced CAS functionality (like, you might have to learn about noncommutative variations on groebner bases). But also, yes sympy is ultra slow with some things.
FilosofumRex•1y ago
There is no general purpose solver available that can symbolically solve 20M equations, and unfortunately, progress in this field has been excruciatingly slow.

It's highly unlikely it's possible, even in theory. Symbolic solvers must explore many known "routes" to expand and simply given equations, without any theoretical guarantees. Even if you found a symbolic solution to your 20M system, it'd have so many terms in it that you'd have to settle for a numerical approximation, just to make sense of them all.

Numerical solvers are of course, a different matter, altogether.

0cf8612b2e1e•1y ago
rudi_mk•1y ago
Damn. I started building exactly the same thing a couple weeks ago.

https://github.com/equationscp/equationscp

hosolmaz•1y ago
It might make more sense to give the model a Jupyter Notebook/code interpreter MCP as a more general case. The environment would have to have sympy, numpy, scipy, matplotlib etc. installed of course
nickysielicki•1y ago
bit more fleshed out than what I slopped together last month for this: https://github.com/sielicki/dogfood/blob/master/scripts/mcp-...

I've found it useful for thought experiments around trading.

Ahh nuts. I was foolishly optimistic because my experience with SAT solvers has been magical where they can effortlessly chew through huge numbers of constraints. Was thinking that computers are really fast and good at math, surely they can balance a bunch of algebra given some guidance.

Ah well. Will have to resign myself to raw numbers.

FilosofumRex•1y ago
I can't recommend SAT solvers enough, the CS community isn't familiar with them and don't appreciate their vast improvements in recent years. If you've the luxury of formulating your 20M system in terms of satisfiability problem, it'd well worth a try.

Unfortunately, most problems in physics(field equations), or engineering (Navier Stokes) can't be formulated as satisfiability problems.