I put together a few experiments where the system rediscovers known laws directly from raw data (solar wind, exoplanets, etc).

Happy to share if you’re curious — still very early but interesting to see what emerges.

The system has no notion of “physics” at all — it’s just searching for compressible structure in the data.

The fact that GR relations emerge from observables suggests that a lot of what we call “laws” might just be the simplest compressions of measurement space.

Still early, but curious how far this goes.

Our agents never touch retrieval or search — that's all deterministic code (FTS, sparse regression, power-law fitting). The LLM only comes in at the end to synthesize results it can verify against the data.

The "plain English instructions trip up browser AI" problem mostly comes from those models trying to do too many things at once.

Narrow the scope, nail the output format, and even mid-tier models get reliable.

It does not use LLMs for discovery — only sparse regression, power-law fitting, and statistical validation.

Results so far:

- Kepler's Third Law (P² = a³ / M) from 3,519 NASA exoplanets — R² = 0.998 - Sun’s ~27-day rotation period from solar wind plasma data — 93% accuracy - Power law T ~ v^3.40 in solar wind (NOAA/NASA spacecraft data) - 5/5 General Relativity predictions from simulated black hole observables — all R² = 1.000 - Chirp mass relationship from 219 LIGO gravitational wave events — R² = 0.998

It also detects when no meaningful law exists — Bitcoin daily prices returned R² = 0.00.

Pipeline:

raw data → feature extraction → candidate law generation → fitting → verification

An LLM (Claude) is only used at the end to interpret results in natural language — it is never involved in the discovery step.

All experiments are fully reproducible.

Code: https://github.com/SaulVanCode/protoscience-nasa-experiments

Comments URL: https://news.ycombinator.com/item?id=47418949

Points: 1

# Comments: 2

I’ve been experimenting with a small sparse-regression system that infers governing equations from raw data, and it can produce a lot of plausible candidates quickly. The hard part is filtering out the ones that look right but violate underlying constraints.

For example, it recovered the Sun’s rotation (~25.1 days vs 27 actual) from solar wind data, but most candidate equations were subtly wrong until you enforced consistency checks.

Feels like systems that treat verification as the source of truth (not just an afterthought) are the ones that will actually scale.

In practice, even relatively small systems can surface meaningful structure. I’ve been using sparse regression (SINDy-style) on raw solar wind data and was able to recover things like the Sun’s rotation period (~25.1 days estimate) and non-trivial scaling laws.

What becomes limiting pretty quickly is compute efficiency when you scale candidate spaces, so compiler-level optimizations like this feel directly relevant to making these approaches practical at larger scales.

I’ve been working on a small (~800-line) Python system that uses sparse regression to discover physical laws from raw data. It was able to estimate the Sun’s rotation (~25.1 days vs 27 days actual) and found a temperature ~ velocity^3.40 relationship in solar wind data.

Having this kind of lightweight stack in the browser could make exploratory science much more accessible.

Comments URL: https://news.ycombinator.com/item?id=47413725

Points: 2

# Comments: 0