Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

New project: a coding and formal verification agent for computational physics and applied mathematics. Auto-generate type-correct DSL code for equations and numerical schemes, autoformalize correctness properties in Lean/Isabelle/Rocq, then compile down to provably-correct C code

52,681 Aufrufe • vor 5 Monaten •via X (Twitter)

15 Kommentare

Profilbild von Guilherme O'Tina
Guilherme O'Tinavor 5 Monaten

the part i wonder about is the gap between 'code is formally correct' and 'the physics model is right'. in computational physics the hard errors are often in modeling assumptions (turbulence closures, boundary conditions), not in numerics. fv guarantees the implementation but the model itself stays experimental

Profilbild von Mathelirium
Matheliriumvor 5 Monaten

How do you plan to bridge the gap between the continuous math model and the discrete DSL without gettin stuck on floating point rounding and stanility issues

Profilbild von Jonathan Gorard
Jonathan Gorardvor 5 Monaten

This work is based on our existing DSL + theorem-prover work which axiomatized the IEEE-754 for floating-point arithmetic as an algebraic structure: All correctness theorems are proved up to machine precision.

Profilbild von Prashanth
Prashanthvor 5 Monaten

This might already be in one of your papers, but: I think the case for formal verification is clear wrt cryptography for example, or pure math. But I’m not sure I understand the case in physics. What does FV add in addition to the theory + experimentation loop?

Profilbild von Jonathan Gorard
Jonathan Gorardvor 5 Monaten

This project is essentially an extremely powerful agentic extension of which perhaps gives some insight into what formal verification means in the context of a numerical code.

Profilbild von FleetingBits
FleetingBitsvor 5 Monaten

i think research on domain specific languages for llms would be quite interesting; sort of the next logical evolution of the racket program; like when do llms benefit from domain specific languages, can they create them usefully, etc...

Profilbild von Ahmed Ibrahim Hamdy
Ahmed Ibrahim Hamdyvor 5 Monaten

Now you are talking -- hope you will open source this -- this has so many good uses

Profilbild von 𝑫𝒂𝒏𝒊𝒆𝒍 𝑺𝒄𝒐𝒕𝒕 𝑴𝒂𝒕𝒕𝒉𝒆𝒘𝒔 🇦🇺
𝑫𝒂𝒏𝒊𝒆𝒍 𝑺𝒄𝒐𝒕𝒕 𝑴𝒂𝒕𝒕𝒉𝒆𝒘𝒔 🇦🇺vor 5 Monaten

That is a big step toward this, Will you be adding deeper layers to deal with the behavioral differences between CISC and RISC CPU architectures so that determinism is nailed down completely? If you can the complete system can generate massive amounts of very high quality synthetic data for further LLM training.

Profilbild von alegator
alegatorvor 5 Monaten

what happens if you give it something like this: tomorrow or over the next few days i will make a video explaining the total proof on paper from start to finish it's lean formalized as far as i can get it on vibes

Profilbild von Rob Coli
Rob Colivor 5 Monaten

I am working on a similar harness! Strong typing and automatic projection to solvers is very valuable in operationalized proof frameworks. Do you mind sharing more of your plans for this project as software, broad release plans, etc.?

Profilbild von Cyclic-Amp
Cyclic-Ampvor 5 Monaten

Hmm..

Profilbild von Deepia
Deepiavor 5 Monaten

Incredible, I didn't know numerical simulations could even be provably correct

Profilbild von Richard Hu
Richard Huvor 5 Monaten

How are you implementing the agent? Custom loop or using some framework?

Profilbild von Giedrius Trump
Giedrius Trumpvor 5 Monaten

🤔

Profilbild von Eray Özkural, PhD - OG AI ⏭️🌟
Eray Özkural, PhD - OG AI ⏭️🌟vor 5 Monaten

We might have to stop you, you're getting too close to our stuff LOL!

Ähnliche Videos

How do you actually formally verify the code underpinning Ethereum's future? In this episode (the finale of the lean Ethereum miniseries), Nico sits down with Alex Hicks (Alexander Hicks), lead of Protocol Snarkification at the Ethereum Foundation, to break down formal verification from first principles. They cover: – What formal verification actually is and the trust boundaries between proof assistants, SMT solvers, and kernels – The full verification stack for RISC-V ZKVMs: from SAIL specs to constraint extraction to soundness proofs – Why writing constraints directly in Lean makes proofs 10–100x more ergonomic – How AI is now proving hard theorems in hours for $200 — and what that unlocks for the whole pipeline They also explore the boundaries problem, why specs can have bugs too, and the end goal of a full Lean stack that bypasses Rust and LLVM entirely. Listen to the full episode ------------------------------------------------------------ TIMECODES: 09:16 – What is formal verification? Proof assistants vs SMT solvers 18:33 – Formal verification of code: specs, semantics, and trust boundaries 29:30 – Formally verifying the Lean Ethereum stack: RISC-V ZKVMs in focus 33:02 – Extracting ZKVM constraints into Lean and proving soundness 36:35 – Writing constraints directly in Lean: 10–100x better proof ergonomics 44:02 – Proving Polishchuk–Spielman in 8 hours for $200 with AI 51:01 – The end goal: a full Lean stack bypassing Rust and LLVM

Zero Knowledge Podcast

15,289 Aufrufe • vor 7 Monaten